>
> Much gnashing of teeth derives from the overlap between syntax for array literal… construction and array concatenation in Julia – largely inherited from Matlab. Perhaps we should just use a different syntax for block matrix construction entirely. One thought would be this:
>
> \`\`\` julia
> | a b
> c d |
> \`\`\`
>
> This has the advantage of being pretty terse and lightweight. For example, the current idiom of expanding a range into an array is \`\[1:10\]\` which would become \`|1:10|\` while \`\[1:10\]\` would construct a one-element array of type \`UnitRange{Int}\`.
If you think you can contribute to better design, you should probably comment on Github.
---
### Author:  [@emil](https://discourse.julialang.org/u/emil)
#### Post date: [December 14, 2016, 5:08pm UTC](https://discourse.julialang.org/t/whats-the-meaning-of-the-array-syntax/938/8 "2016-12-14T17:08:22Z")
It looks like for many people, the preferred solution is to disentangle array construction and concatenation ops. I agree with that. That idea has not gained traction in some years, although it should happen ASAP before 0.6/1.0 if it will ever happen …
A smaller improvement to the current situation along the above lines could be to make `;` return a `nx1 Array`. That would make more sense to me, but it then seems to suggest changing `vcat` to return an `nx1 Array`. Thoughts?
---
### Author:  [@StefanKarpinski](https://discourse.julialang.org/u/StefanKarpinski)
#### Post date: [December 14, 2016, 7:37pm UTC](https://discourse.julialang.org/t/whats-the-meaning-of-the-array-syntax/938/9 "2016-12-14T19:37:39Z")
This has changed significantly in 0.4 and 0.5 (and possibly already in 0.3, I forget). That’s as fast as it could be changed without silently breaking people’s code. Changing syntax in a system that’s actively used by a lot of people is slow, delicate work. Using `[]` with `,` separators now only ever means array construction whereas `;` and space as separators only mean vertical and horizontal concatenation, respectively (which is why you can’t mix `,` with `;` or space). So this is now consistent once you understand what they mean,and it lets you do both kinds of operations.
I used to feel that we should get rid of space-sensitive syntax everywhere, but that was partly because there were occasional little bugs with it. It’s been a long time since there have been any such bugs and people seem to have gotten used to it – especially since the rules are now consistent everywhere there’s a space-sensitive context.
Are you suggesting that we stop using `[]` for array concatenation entirely? Or are there some corner cases of `[]` syntax that you’ve found annoying? Specifically, do you mean that you think `[1;2;3]` should produce a 3x1 matrix rather than a 3-element vector? I suppose that there’s a certain consistency to having all concatenation operations produce matrices, but that would leave us without the ability to write `[v;w]` to concatenate two vectors and get another vector, so there’s a tradeoff. If you’ve got a good argument for why it’s a better choice, I’d love to hear it.
---
### Author:  [@jballanc](https://discourse.julialang.org/u/jballanc)
#### Post date: [December 15, 2016, 7:33am UTC](https://discourse.julialang.org/t/whats-the-meaning-of-the-array-syntax/938/10 "2016-12-15T07:33:46Z")
What about embracing space-sensitive syntax fully?
Personally, what I find confusing is trying to remember that `;` means vertical _concatenation_. One source of confusion is that `[1,2,3]` and `[1;2;3]` generate the same result, but for different reasons. Luckily, a newline works as a stand-in for `;` and does pretty much exactly what you’d expect:
```julia
julia> a = [1 2]
1×2 Array{Int64,2}:
1 2
julia> b = [3 4]
1×2 Array{Int64,2}:
3 4
julia> [a b
b a]
2×4 Array{Int64,2}:
1 2 3 4
3 4 1 2
```
In fact, one can avoid the whole confusion around `,` and `;` entirely and just use whitespace instead (and if you are worried about taking up too many lines of code but still want to avoid the confusion, there’s always `hcat` and `vcat`).
---
### Author:  [@emil](https://discourse.julialang.org/u/emil)
#### Post date: [December 15, 2016, 8:02am UTC](https://discourse.julialang.org/t/whats-the-meaning-of-the-array-syntax/938/11 "2016-12-15T08:02:37Z")
No, I don’t want to suggest any really big changes, not now.
It would make more sense to me if `;` produced an `nx1` matrix instead of a vector. So the simple rule becomes: _commas do vectors, semicolons and spaces concatenate and produce matrices._
That would entail the following changes.
- `vcat` produces `nx1` matrices.
- `hcat` produces `1xn` matrices
- `hvcat` produces `mxn` matrices
- a new function `cat` takes vectors and returns a vector
The idea is that `hcat` and `vcat`, with their direction explicitly included, only make sense in a 2D context, and it helps separate vectors and `1xn/nx1` matrices more meaningfully. The convenient `[v;w]` becomes `cat(v,w)` or `cat([v,w])`.
To me that’s cleaner, but maybe other beginners would be confused by distinguishing vectors/`1xn`,`nx1` matrices this way. Would be interested to get other people’s ideas.
---
### Author:  [@Tamas\_Papp](https://discourse.julialang.org/u/Tamas_Papp)
#### Post date: [December 15, 2016, 9:05am UTC](https://discourse.julialang.org/t/whats-the-meaning-of-the-array-syntax/938/12 "2016-12-15T09:05:12Z")
> [@emil](#):
>
> It would make more sense to me if ; produced an nx1 matrix instead of a vector.
I can sympathize with this.
---
### Author:  [@StefanKarpinski](https://discourse.julialang.org/u/StefanKarpinski)
#### Post date: [December 15, 2016, 2:11pm UTC](https://discourse.julialang.org/t/whats-the-meaning-of-the-array-syntax/938/13 "2016-12-15T14:11:40Z")
> - vcat produces nx1 matrices.
> - hcat produces 1xn matrices
Minor point: `vcat` and `hcat` can produce arbitrary width and height matrices if their inputs are wide/tall respectively. E.g.:
```julia
julia> [rand(2,2); rand(3,2)]
5×2 Array{Float64,2}:
0.187175 0.629967
0.706591 0.938334
0.781615 0.0100944
0.430575 0.95716
0.0332201 0.211566
julia> [rand(2,2) rand(2,3)]
2×5 Array{Float64,2}:
0.00450999 0.636033 0.674548 0.369836 0.925724
0.88356 0.163572 0.472557 0.960674 0.407421
```
---
### Author:  [@jebej](https://discourse.julialang.org/u/jebej)
#### Post date: [December 15, 2016, 3:28pm UTC](https://discourse.julialang.org/t/whats-the-meaning-of-the-array-syntax/938/14 "2016-12-15T15:28:35Z")
> [@emil](#):
>
> It would make more sense to me if ; produced an nx1 matrix instead of a vector. So the simple rule becomes: commas do vectors, semicolons and spaces concatenate and produce matrices.
I agree too that this you make more sense. Right now, it seems [the recommended way](http://cheatsheets.quantecon.org/) to make an nx1 array is with the transpose operation, which could lead to unnoticed mistakes if you don’t realize that it gives a complex transpose by default:
```julia
julia> [1+2im 2+3im]'
2×1 Array{Complex{Int64},2}:
1-2im
2-3im
```
I was actually surprised at the current behaviour since [the manual (very vaguely) implies](http://docs.julialang.org/en/release-0.5/manual/arrays/#concatenation) that the semicolon gives “arrays” as opposed to the line right above that explain the comma gives “1-d arrays”. The special syntax table also gives the impression spaces and semicolons should output the same type of object.
---
### Author:  [@bkamins](https://discourse.julialang.org/u/bkamins)
#### Post date: [December 18, 2016, 9:30am UTC](https://discourse.julialang.org/t/whats-the-meaning-of-the-array-syntax/938/15 "2016-12-18T09:30:42Z")
Additionally you can create nx1 array from 1-d vector (or iterable) is by using `hcat`, eg.
```julia
hcat([1, 2, 3])
hcat(1:3)
```
---
### Author:  [@pitao](https://discourse.julialang.org/u/pitao)
#### Post date: [December 18, 2016, 11:17am UTC](https://discourse.julialang.org/t/whats-the-meaning-of-the-array-syntax/938/16 "2016-12-18T11:17:07Z")
That cheat sheet is incorrect.
```
A.' # transpose of A
A' # CONJUGATE transpose of A
```
(i.e. Same as Matlab)
PS there is a whole separate discussion about the merits of having a syntax use `.` in a non-broadcasty way.
---
### Author:  [@StefanKarpinski](https://discourse.julialang.org/u/StefanKarpinski)
#### Post date: [January 3, 2017, 9:08pm UTC](https://discourse.julialang.org/t/whats-the-meaning-of-the-array-syntax/938/17 "2017-01-03T21:08:11Z")
x-ref: [https://github.com/JuliaLang/julia/issues/19622](https://github.com/JuliaLang/julia/issues/19622)
---
### Author:  [@fengyang.wang](https://discourse.julialang.org/u/fengyang.wang)
#### Post date: [January 3, 2017, 11:29pm UTC](https://discourse.julialang.org/t/whats-the-meaning-of-the-array-syntax/938/18 "2017-01-03T23:29:45Z")
I have to say that I am not a fan of `vcat` returning a matrix even if the concatenated arrays are one-dimensional. I do use vectors more than matrices, and overall I think a one-dimensional vector is a more useful result type than an n×1 matrix in a greater number of situations.