Array comprehensions are great to construct multidimensional arrays:

- The default case

```
julia> [x * y for x in 1:10, y in 1:10 ]
10×10 Array{Int64,2}:
1 2 3 4 5 6 7 8 9 10
2 4 6 8 10 12 14 16 18 20
3 6 9 12 15 18 21 24 27 30
4 8 12 16 20 24 28 32 36 40
5 10 15 20 25 30 35 40 45 50
6 12 18 24 30 36 42 48 54 60
7 14 21 28 35 42 49 56 63 70
8 16 24 32 40 48 56 64 72 80
9 18 27 36 45 54 63 72 81 90
10 20 30 40 50 60 70 80 90 100
```

but I noticed some inconsistencies:

- Separating for loops does not construct a multidimensional array

```
julia> [x * y for x in 1:10 for y in 1:10 ]
100-element Array{Int64,1}:
```

- Adding an
`if`

statement gives a 1d Array.

```
julia> [
x * y
for x in 1:10, y in 1:10 if y > 5
]
50-element Array{Int64,1}:
```

- Adding separate for loops AND
`if`

statements

```
julia> [
x * y
for x in 1:10 if x > 4
for y in 1:10 if y > 5
]
30-element Array{Int64,1}:
```

The ones that make sense to me are the default case and case 2. because subsetting of `x`

and `y`

is arbitrary.

- The reasoning why case 1. would result in a 1d-Array is not clear to me and
- I would propose that case 3. should result in a 2d array with properly subset columns and rows as a new feature.