Fixed grammar in the first part

Author: zaleslaw

docs/StardustDocs/topics/ColumnSelectors.md

@@ -2,7 +2,7 @@
 
 <!---IMPORT org.jetbrains.kotlinx.dataframe.samples.api.Access-->
 
-[`DataFrame`](DataFrame.md) provides DSL for selecting arbitrary set of columns.
+[`DataFrame`](DataFrame.md) provides a DSL for selecting an arbitrary set of columns.
 
 Column selectors are used in many operations:
 
@@ -187,19 +187,19 @@ df.select {
     Person::name.single { it.name().startsWith("first") }
 }
 
-// recursive traversal of all columns, excluding ColumnGroups from result
+// recursive traversal of all columns, excluding ColumnGroups from a result
 df.select { cols { !it.isColumnGroup() }.recursively() }
 
-// depth-first-search traversal of all columns, including ColumnGroups in result
+// depth-first-search traversal of all columns, including ColumnGroups in a result
 df.select { all().recursively() }
 
 // recursive traversal with condition
 df.select { cols { it.name().contains(":") }.recursively() }
 
-// recursive traversal of columns of given type
+// recursive traversal of columns of a given type
 df.select { colsOf<String>().rec() }
 
-// all columns except given column set
+// all columns except a given column set
 df.select { except { colsOf<String>() } }
 
 // union of column sets

docs/StardustDocs/topics/DataColumn.md

@@ -7,9 +7,9 @@ See [how to create columns](createColumn.md)
 
 ### Properties
 * `name: String` — name of the column, should be unique within containing dataframe
-* `path: ColumnPath` — path to the column, depends on the way column was retrieved from dataframe
+* `path: ColumnPath` — path to the column, depends on the way column was retrieved from the dataframe
 * `type: KType` — type of elements in the column
-* `hasNulls: Boolean` — flag indicating whether column contains `null` values
+* `hasNulls: Boolean` — flag indicating whether a column contains `null` values
 * `values: Iterable<T>` — column data
 * `size: Int` — number of elements in the column
 
@@ -24,7 +24,7 @@ It can store values of primitive (integers, strings, decimals etc.) or reference
 
 #### ColumnGroup
 
-Container for nested columns. Is used to create column hierarchy. 
+Container for nested columns. It is used to create column hierarchy. 
 
 #### FrameColumn
 
@@ -36,7 +36,11 @@ Special case of [`ValueColumn`](#valuecolumn) that stores other [`DataFrames`](D
 
 ## Column accessors
 
-`ColumnAccessors` are used for [typed data access](columnAccessorsApi.md) in [`DataFrame`](DataFrame.md). `ColumnAccessor` stores column [`name`](#properties) (for top-level columns) or column path (for nested columns), has type argument that corresponds to [`type`](#properties) of thep column, but it doesn't contain any actual data.
+`ColumnAccessors` are used for [typed data access](columnAccessorsApi.md) in [`DataFrame`](DataFrame.md).
+`ColumnAccessor`
+stores column [`name`](#properties) (for top-level columns) or column path (for nested columns),
+has type argument that corresponds to [`type`](#properties) of the column,
+but it doesn't contain any actual data.
 
 <!---FUN columnAccessorsUsage-->
 
@@ -45,11 +49,11 @@ val age by column<Int>()
 
 // Access fourth cell in the "age" column of dataframe `df`.
 // This expression returns `Int` because variable `age` has `ColumnAccessor<Int>` type.
-// If dataframe `df` has no column "age" or column "age" has type which is incompatible with `Int`,
-// runtime exception will be thrown.
+// If dataframe `df` has no column "age" or column "age" has a type which is incompatible with `Int`,
+//  a runtime exception will be thrown.
 df[age][3] + 5
 
-// Access first cell in the "age" column of dataframe `df`.
+// Access the first cell in the "age" column of dataframe `df`.
 df[0][age] * 2
 
 // Returns new dataframe sorted by age column (ascending)
@@ -74,7 +78,7 @@ val name by column<String>()
 
 <!---END-->
 
-To assign column name explicitly, pass it as an argument.
+To assign a column name explicitly, pass it as an argument.
 
 <!---FUN createColumnAccessorRenamed-->
 
@@ -106,7 +110,7 @@ val firstName by name.column<String>()
 
 <!---END-->
 
-You can also create virtual accessor that doesn't point to a real column but computes some expression on every data access:
+You can also create a virtual accessor that doesn't point to a real column but computes some expression on every data access:
 
 <!---FUN columnAccessorComputed-->
 <tabs>

docs/StardustDocs/topics/DataRow.md

@@ -10,12 +10,12 @@
 * `next(): DataRow?` — next row (`null` for the last row)
 * `diff { rowExpression }: T` — difference between results of [row expression](#row-expressions) calculated for current and previous rows
 * `values(): List<Any?>` — list of all cell values from the current row
-* `valuesOf<T>(): List<T>` — list of values of given type 
+* `valuesOf<T>(): List<T>` — list of values of a given type 
 * `columnsCount(): Int` — number of columns
 * `columnNames(): List<String>` — list of all column names
 * `columnTypes(): List<KType>` — list of all column types 
 * `namedValues(): List<NameValuePair<Any?>>` — list of name-value pairs where `name` is a column name and `value` is cell value
-* `namedValuesOf<T>(): List<NameValuePair<T>>` — list of name-value pairs where value has given type 
+* `namedValuesOf<T>(): List<NameValuePair<T>>` — list of name-value pairs where value has given a type 
 * `transpose(): DataFrame<NameValuePair<*>>` — dataframe of two columns: `name: String` is column names and `value: Any?` is cell values
 * `transposeTo<T>(): DataFrame<NameValuePair<T>>`— dataframe of two columns: `name: String` is column names and `value: T` is cell values
 * `getRow(Int): DataRow` — row from [`DataFrame`](DataFrame.md) by row index
@@ -54,7 +54,7 @@ Row condition is a special case of [row expression](#row-expressions) that retur
 // Row condition is used to filter rows by index
 df.filter { index() % 5 == 0 }
 
-// Row condition is used to drop rows where `age` is the same as in previous row
+// Row condition is used to drop rows where `age` is the same as in the previous row
 df.drop { diff { age } == 0 }
 
 // Row condition is used to filter rows for value update
@@ -76,10 +76,11 @@ The following [statistics](summaryStatistics.md) are available for `DataRow`:
 * `rowStd`
 * `rowMedian`
 
-These statistics will be applied only to values of appropriate types and incompatible values will be ignored.
-For example, if [`DataFrame`](DataFrame.md) has columns of type `String` and `Int`, `rowSum()` will successfully compute sum of `Int` values in a row and ignore `String` values.
+These statistics will be applied only to values of appropriate types, and incompatible values will be ignored.
+For example, if [`DataFrame`](DataFrame.md) has columns of a type `String` and `Int`,
+`rowSum()` will successfully compute a sum of `Int` values in a row and ignore `String` values.
 
-To apply statistics only to values of particular type use `-Of` versions:
+To apply statistics only to values of a particular type, use `-Of` versions:
 * `rowMaxOf<T>`
 * `rowMinOf<T>`
 * `rowSumOf<T>`

docs/StardustDocs/topics/access.md

@@ -18,5 +18,5 @@ df.values() // Sequence<Any?>
 **Learn how to:**
 * [Access data by index](indexing.md)
 * [Iterate over data](iterate.md)
-* [Get single row](getRow.md)
+* [Get a single row](getRow.md)
 * [Get single column](getColumns.md)

docs/StardustDocs/topics/add.md

@@ -5,7 +5,7 @@
 Returns [`DataFrame`](DataFrame.md) which contains all columns from original [`DataFrame`](DataFrame.md) followed by newly added columns. 
 Original [`DataFrame`](DataFrame.md) is not modified.
 
-## Create new column and add it to [`DataFrame`](DataFrame.md)
+## Create a new column and add it to [`DataFrame`](DataFrame.md)
 
 ```text
 add(columnName: String) { rowExpression }
@@ -44,7 +44,8 @@ df.add("year of birth") { 2021 - "age"<Int>() }
 
 See [row expressions](DataRow.md#row-expressions)
 
-You can use `newValue()` function to access value that was already calculated for preceding row. It is helpful for recurrent computations:
+You can use `newValue()` function to access value that was already calculated for the preceding row.
+It is helpful for recurrent computations:
 
 <!---FUN addRecurrent-->
 
@@ -223,7 +224,9 @@ df.add(df1, df2)
 
 ## addId
 
-Adds column with sequential values 0, 1, 2,... New column will be added in the beginning of columns list and will become the first column in [`DataFrame`](DataFrame.md).
+Adds column with sequential values 0, 1, 2,...
+New column will be added in the beginning of a column list
+and will become the first column in [`DataFrame`](DataFrame.md).
 
 ```
 addId(name: String = "id")

docs/StardustDocs/topics/adjustSchema.md

@@ -1,7 +1,7 @@
 [//]: # (title: Adjust schema)
 
-[`DataFrame`](DataFrame.md) interface has type argument `T` that doesn't affect contents of [`DataFrame`](DataFrame.md), 
-but marks [`DataFrame`](DataFrame.md) with a type that represents data schema that this [`DataFrame`](DataFrame.md) is supposed to have.
+[`DataFrame`](DataFrame.md) interface has type argument `T` that doesn't affect the contents of [`DataFrame`](DataFrame.md), 
+but marks [`DataFrame`](DataFrame.md) with a type that represents the data schema that this [`DataFrame`](DataFrame.md) is supposed to have.
 This argument is used to generate [extension properties](extensionPropertiesApi.md) for typed data access.
 
 Another place where this argument has a special role is in [interop with data classes](collectionsInterop.md#interop-with-data-classes):

docs/StardustDocs/topics/apiLevels.md

@@ -2,16 +2,21 @@
 
 <!---IMPORT org.jetbrains.kotlinx.dataframe.samples.api.ApiLevels-->
 
-By nature data frames are dynamic objects, column labels depend on the input source and also new columns could be added
-or deleted while wrangling. Kotlin, in contrast, is a statically typed language and all types are defined and verified
-ahead of execution. That's why creating a flexible, handy, and, at the same time, safe API to a data frame is tricky.
+By nature, data frames are dynamic objects,
+column labels depend on the input source, and also new columns could be added
+or deleted while wrangling.
+Kotlin, in contrast, is a statically typed language and all types are defined and verified
+ahead of execution.
 
-In the Kotlin DataFrame library we provide four different ways to access columns, and, while they are essentially different, they
+That's why creating a flexible, handy, and, at the same time, safe API to a data frame is tricky.
+
+In the Kotlin DataFrame library, we provide four different ways to access columns,
+and, while they are essentially different, they
 look pretty similar in the data wrangling DSL.
 
 ## List of Access APIs
 
-Here's a list of all APIs in order of increasing safety.
+Here's a list of all APIs in order to increase safety.
 
 * [**String API**](stringApi.md) <br/>
   Columns are accessed by `string` representing their name. Type-checking is done at runtime, name-checking too.
@@ -128,9 +133,9 @@ df.add("lastName") { name.split(",").last() }
 
 </tabs>
 
-The `titanic.csv` file could be found [here](https://github.com/Kotlin/dataframe/blob/master/data/titanic.csv).
+The `titanic.csv` file can be found [here](https://github.com/Kotlin/dataframe/blob/master/data/titanic.csv).
 
-# Comparing the APIs
+# Comparing APIs
 
 The [String API](stringApi.md) is the simplest and unsafest of them all. The main advantage of it is that it can be
 used at any time, including when accessing new columns in chain calls. So we can write something like:
@@ -144,17 +149,17 @@ We don't need to interrupt a function call chain and declare a column accessor o
 
 In contrast, generated [extension properties](extensionPropertiesApi.md) are the most convenient and the safest API. 
 Using it, you can always be sure that you work with correct data and types. 
-But its bottleneck is the moment of generation. 
-To get new extension properties you have to run a cell in a notebook, 
+But its bottleneck is the moment of a generation. 
+To get new extension properties, you have to run a cell in a notebook,
 which could lead to unnecessary variable declarations.
-Currently, we are working on compiler a plugin that generates these properties on the fly while typing!
+Currently, we are working on a compiler with a plugin that generates these properties on the fly while typing!
 
 The [Column Accessors API](columnAccessorsApi.md) is a kind of trade-off between safety and needs to be written ahead of
 the execution type declaration. It was designed to better be able to write code in an IDE without a notebook experience. 
 It provides type-safe access to columns but doesn't ensure that the columns really exist in a particular data frame.
 
 The [KProperties API](KPropertiesApi.md) is useful when you already have declared classed in your application business
-logic with fields that correspond columns of a data frame.
+logic with fields that correspond to columns of a data frame.
 
 <table>
     <tr>

docs/StardustDocs/topics/cast.md

@@ -8,9 +8,12 @@ cast<T>(verify = false)
 ```
 
 **Parameters:**
-* `verify: Boolean = false` — when `true`, throws exception if [`DataFrame`](DataFrame.md) doesn't match given schema. Otherwise, just changes format type without actual data check.
+* `verify: Boolean = false` —
+  when `true`, throws exception if [`DataFrame`](DataFrame.md) doesn't match the given schema. 
+Otherwise, just change a format type without actual data check.
 
-Use this operation to change formal type of [`DataFrame`](DataFrame.md) to match expected schema and enable generated [extension properties](extensionPropertiesApi.md) for it.
+Use this operation to change a formal type of [`DataFrame`](DataFrame.md)
+to match the expected schema and enable generated [extension properties](extensionPropertiesApi.md) for it.
 
 ```kotlin
 @DataSchema

docs/StardustDocs/topics/collectionsInterop.md

@@ -7,16 +7,23 @@ _Kotlin DataFrame_ and _Kotlin Collection_ represent two different approaches to
 * [`DataFrame`](DataFrame.md) stores data by fields/columns
 * `Collection` stores data by records/rows
 
-Although [`DataFrame`](DataFrame.md) doesn't implement [`Collection`](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/-collection/#kotlin.collections.Collection) or [`Iterable`](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/-iterable/) interface, it has many similar operations, 
-such as [`filter`](filter.md), [`take`](sliceRows.md#take), [`first`](first.md), [`map`](map.md), [`groupBy`](groupBy.md) etc.
+Although [`DataFrame`](DataFrame.md)
+doesn't implement [`Collection`](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/-collection/#kotlin.collections.Collection)
+or [`Iterable`](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/-iterable/)
+interface, it has many similar operations,
+such as [`filter`](filter.md), [`take`](sliceRows.md#take),
+[`first`](first.md), [`map`](map.md), [`groupBy`](groupBy.md) etc.
 
 [`DataFrame`](DataFrame.md) has two-way compatibility with [`Map`](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/-map/) and [`List`](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/-list/):
 * `List<T>` -> `DataFrame<T>`: [toDataFrame](createDataFrame.md#todataframe)
 * `DataFrame<T>` -> `List<T>`: [toList](toList.md)
 * `Map<String, List<*>>` -> `DataFrame<*>`: [toDataFrame](createDataFrame.md#todataframe)
 * `DataFrame<*>` -> `Map<String, List<*>>`: [toMap](toMap.md)
 
-Columns, rows and values of [`DataFrame`](DataFrame.md) can be accessed as [`List`](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/-list/), [`Iterable`](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/-iterable/) and [`Sequence`](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.sequences/-sequence/) accordingly:
+Columns, rows, and values of [`DataFrame`](DataFrame.md)
+can be accessed as [`List`](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/-list/),
+[`Iterable`](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/-iterable/)
+and [`Sequence`](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.sequences/-sequence/) accordingly:
 
 <!---FUN getRowsColumns-->
 
@@ -54,7 +61,8 @@ val df = list.toDataFrame()
 
 <!---END-->
 
-Mark original data class with [`DataSchema`](schemas.md) annotation to get [extension properties](extensionPropertiesApi.md) and perform data transformations.
+Mark the original data class with [`DataSchema`](schemas.md)
+annotation to get [extension properties](extensionPropertiesApi.md) and perform data transformations.
 
 <!---FUN listInterop3-->
 
@@ -87,6 +95,6 @@ val result = df2.toListOf<Output>()
 
 <!---END-->
 
-### Converting columns with objects instances to ColumnGroup
+### Converting columns with object instances to ColumnGroup
 
 [unfold](unfold.md) can be used as [`toDataFrame()`](createDataFrame.md#todataframe) analogue for specific columns inside existing dataframes

docs/StardustDocs/topics/columnAccessorsApi.md

@@ -7,7 +7,7 @@ For frequently accessed columns type casting can be reduced by [Column Accessors
 <!---FUN accessors1-->
 
 ```kotlin
-val survived by column<Boolean>() // accessor for Boolean column with name 'survived'
+val survived by column<Boolean>() // accessor for Boolean column with the name 'survived'
 val home by column<String>()
 val age by column<Int?>()
 val name by column<String>()
@@ -29,7 +29,7 @@ DataFrame.read("titanic.csv")
 
 <!---END-->
 
-The `titanic.csv` file could be found [here](https://github.com/Kotlin/dataframe/blob/master/data/titanic.csv).
+The `titanic.csv` file can be found [here](https://github.com/Kotlin/dataframe/blob/master/data/titanic.csv).
 
 <warning>
 Note that it still doesn’t solve the problem of whether the column actually exists in a data frame, but reduces type casting.