Review suggestions

Co-authored-by: Richard Sill <[email protected]>

Author: hvub

modules/ROOT/pages/queries/composed-queries/sequential-queries.adoc

@@ -149,7 +149,7 @@ This allows you to control variable scope similarly to what you can do with `WIT
 == Aggregation after `NEXT`
 
 `NEXT` passes the result table as a whole to the subsequent query.
-This particularly useful when aggregating values.
+This is particularly useful when aggregating values.
 
 In the following example, `NEXT` passes the variable `customer` to the second query:
 
@@ -187,7 +187,7 @@ end::sequential_queries_aggregation_example[]
 [[union-after-next]]
 === Using `UNION` after `NEXT`
 
-When a `UNION` query follows a `NEXT` the full table of intermediate results are passed into all arms of the `UNION` query.
+If a `UNION` query follows a `NEXT` the full table of intermediate results is passed into all arms of the `UNION` query.
 
 .`UNION` after `NEXT`
 tag::sequential_queries_union_example[]
@@ -234,7 +234,7 @@ end::sequential_queries_union_example[]
 [[union-before-next]]
 === Using `UNION` before `NEXT`
 
-When a `UNION` query precedes a `NEXT` the full result of the `UNION` is passed into the subsequent query.
+If a `UNION` query precedes a `NEXT` the full result of the `UNION` is passed to the subsequent query.
 
 .`UNION` before `NEXT`
 [source,cypher]
@@ -318,7 +318,7 @@ RETURN customer.firstName AS plantCustomer
 [[next-and-call]]
 == Interactions with `CALL` subqueries
 
-`CALL` subqueries pass the table of intermediate rules to the subquery row-by-row, while `NEXT` passes the table as a whole.
+`CALL` subqueries pass the table of intermediate results to the subquery row by row, while `NEXT` passes the table as a whole.
 When `NEXT` is wrapped within a `CALL` subquery, the first query gets passed only a single row at a time.
 This can be used to compute more complex aggregates in groups.
 
@@ -358,13 +358,15 @@ RETURN p.name AS product,
 2+d|Rows: 5
 |===
 
-In this example, we compute for each non-coffee product the percentage of customers that also bought coffee.
+This example computes the percentage of customers that also bought coffee for each non-coffee product.
 So for each product `p`, the subquery find all pairs of a customer `c` of product `p` and another product `otherProduct` that customer has also bought.
-The first `NEXT` passes these pairs as a whole into a `UNION`, so that the query can
-(1) count all customers in the first arm of the union and
-(2) count the customers who also bought coffee in the second arm of the union.
-The `UNION` produce two rows -- one from each arm.
-The second `NEXT` passes these two rows as a whole into a query the aggregates them into a single row, which is the result of the `CALL` subquery.
+The first `NEXT` passes these pairs as a whole into a `UNION`, so that the query can:
+
+. count all customers in the first arm of the union.
+. count the customers who also bought coffee in the second arm of the union.
+
+The `UNION` produces two rows -- one from each arm.
+The second `NEXT` passes these two rows as a whole to a query that aggregates them into a single row, which is the result of the `CALL` subquery.
 
 [NOTE]
 ====
@@ -375,9 +377,9 @@ The second `NEXT` passes these two rows as a whole into a query the aggregates t
 == Interactions with conditional queries
 
 [[conditional-queries-inside-next]]
-=== Using conditional query before or after `NEXT`
+=== Using conditional queries before or after `NEXT`
 
-Conditional queries act similar to `CALL` by processing the incoming table of intermediate result row-by-row.
+Conditional queries act similar to `CALL` by processing the incoming table of intermediate result row by row.
 A conditional query following a `NEXT` acts equivalent to a conditional query wrapped in a `CALL` subquery.
 
 .Conditional query inside `NEXT`