fix typos and code

Author: yixuan

src/stan-users-guide/parallelization.qmd

@@ -16,9 +16,9 @@ be used with multi-processing.
 The advantages of reduce with summation are:
 
 1. More flexible argument interface, avoiding the packing and
-   unpacking that is necessary with rectanguar map.
+   unpacking that is necessary with rectangular map.
 2. Partitions data for parallelization automatically (this is done manually
-   in rectanguar map).
+   in rectangular map).
 3. Is easier to use.
 
 The advantages of rectangular map are:
@@ -92,7 +92,7 @@ See details [below](#reduce-sum-grainsize).
 
 For efficiency and convenience additional
 shared arguments can be passed to every term in the sum. So for the
-array ```{ x1, x2, ... }``` and the shared arguments ```s1, s2, ...```stan
+array ```{ x1, x2, ... }``` and the shared arguments ```s1, s2, ...```
 the effective sum (with individual terms) looks like: 
 
 ```stan
@@ -137,7 +137,7 @@ without modification from the ```reduce_sum``` / `reduce_sum_static` call)
 The user-provided function ```f``` is expected to compute the partial
 sum with the terms ```start``` through ```end``` of the overall
 sum. The user function is passed the subset ```x[start:end]``` as
-```x_slice```. ```start``` and  ```end``` are passed so that ```f```stan
+```x_slice```. ```start``` and  ```end``` are passed so that ```f```
 can index any of the tailing ```sM``` arguments as necessary. The
 trailing ```sM``` arguments are passed without modification to every
 call of ```f```.
@@ -452,8 +452,8 @@ data {
 }
 transformed data {
   // K = 3 shards
-  array[3, 4] = { y[1:4], y[5:8], y[9:12] int ys };
-  array[3, 4] = { x[1:4], x[5:8], x[9:12] real xs };
+  array[3, 4] int ys = { y[1:4], y[5:8], y[9:12] };
+  array[3, 4] real xs = { x[1:4], x[5:8], x[9:12] };
   array[3] vector[0] theta;
 }
 parameters {