Lisp can be at least as high level and expressive as any other language.
s-exps are basically coding at the level of the AST, which for many programming tasks is a powerful level of both abstraction and control.
But this interface tends to work much better on tree-like structures (the most simple of which is the list, which in it's simplest case is a cons cell, Lisp's most fundamental particle).
Most programming tasks can boil down to tree manipulation, but large matrices feel a bit out of place with this interface because you are basically to working with arrays (which in it's simplest cases is a pointer to a memory address, which is C's fundamental particle). C like languages (I know, technical ALGO-like), tend to feel more natural for these tasks.
But of course if you can manipulate trees easily, you can manipulate code easily which gives you...
> Lisp can be at least as high level and expressive as any other language.
In practice, for Lisp this is also a weakness. Again, I love Lisps in general, and of course any Lisp and especially Common Lisp (with it's exceptionally excellent macro system) can do anything you want.
However, my (and many others) experience has been that this leads to is it becomes very easy to create code that is amazing for the original developer, but very difficult for new developers to get their head around. Hence the adage "Lisp is optimal for team sizes of one."
You could undoubtable build the worlds most elegant interface to working with matrices in Lisp, but now you essentially have a new language.
[1 2 3; 4 5 6; 7 8 9]
#2A((1 2 3) (3 4 5) (7 8 9))
[[1,2,3],[4,5,6],[7,8,9]]
julia> [1,2,3] # An array of `Int`s
3-element Vector{Int64}:
1
2
3
julia> [1:2, 4:5] # Has a comma, so no concatenation occurs.
2-element Vector{UnitRange{Int64}}:
1:2
4:5
julia> [1:2 4:5 7:8]
2×3 Matrix{Int64}:
1 4 7
2 5 8
julia> [[1,2] [4,5] [7,8]]
2×3 Matrix{Int64}:
1 4 7
2 5 8
julia> [1 2
3 4]
2×2 Matrix{Int64}:
1 2
3 4
julia> a=[1 2 5 8 9; 3 4 2 1 33]
2×5 Array{Int64,2}:
1 2 5 8 9
3 4 2 1 33
> You could undoubtable build the worlds most elegant interface to working with matrices in Lisp, but now you essentially have a new language.
What?
Since we're in lisp, you can imagine some macros that make working with matrices easier!