## Background

I know that Julia’s design is very reasonable, especially from the viewpoint of mathematics; it’s my favorite feature of Julia. For example, Julia uses `*`

as a string join operator instead of `+`

, unlike many programming languages, because it makes sense in the context of (abstract) algebra:

is much more natural than

obviously. But sometimes I miss some operators in Python. In this context, `+`

serves as a vector concatenator.

```
Python 3.11.4 (tags/v3.11.4:d2340ef, Jun 7 2023, 05:45:37) [MSC v.1934 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> x = [1,2]
>>> y = [3,4]
>>> x + y
[1, 2, 3, 4]
```

Of course, I think `vcat(x, y)`

or `[x; y]`

in Julia are also great.

```
julia> x = [1,2]
2-element Vector{Int64}:
1
2
julia> y = [3,4]
2-element Vector{Int64}:
3
4
julia> vcat(x, y)
4-element Vector{Int64}:
1
2
3
4
julia> [x; y]
4-element Vector{Int64}:
1
2
3
4
```

I understand that this grammatical consistency is important for reading or writing code. Most significantly, I know that `x + y`

is totally weird in a mathematical sense.

Then how about \oplus? Usually, in general mathematics, **a direct sum** \oplus (`\oplus`

) refers to a Cartesian product of vector space or some algebraic structures. For instance, the plane \mathbb{R}^{2} and the z-axis \mathbb{R}^{1} could be merged in 3-dimensional space \mathbb{R}^{3} by \mathbb{R}^{3} = \mathbb{R}^{2} \oplus \mathbb{R}^{1}. In a coordinate system, it’s exactly the same as vector concatenation, (x, y, z) = (x, y) \oplus (z).

## Implementation

Below are simple implementations. If you love these, you can use them personally even if Julia doesn’t change. I believe all of you guys have a personal library, just for yourselves.

### Binary operation

Please note that I didn’t check for performance issues. `vcat`

or other ways could be more efficient and fast.

```
julia> ⊕(x, y) = [x; y]
⊕ (generic function with 1 method)
julia> [1, 2] ⊕ [3, 4]
4-element Vector{Int64}:
1
2
3
4
```

### \bigoplus_{k} A_{k}

Since \oplus is a binary operation, we can generalize it using `reduce`

.

```
julia> reduce(⊕, [[1, 2], [3, 4], [5, 6, 7]])
7-element Vector{Int64}:
1
2
3
4
5
6
7
```

The following is a method form.

```
julia> ⊕(x, y...) = reduce(⊕, [x, y...])
⊕ (generic function with 2 methods)
julia> ⊕([1, 2], [3, 4], [5, 6, 7])
7-element Vector{Int64}:
1
2
3
4
5
6
7
```

### Clean code

```
⊕(x, y) = [x; y]
⊕(x, y...) = reduce(⊕, [x, y...])
```

Any comments or ideas are helpful to me. Thank you for your attention!