A friend of mine introduced [array broadcasting](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html) in the Python `NumPy` package which is very convenient (and also highly efficient).

The idea is perfectly shown in this picture:

![scheme of the broadcasting method in NumPy][1]

Basically, the method first checks the shape of the two arrays; if a dimension is not the same, it "broadcasts" that dimension to generate arrays of the same dimensions.

Here is an excerpt from the [General Broadcasting Rules](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html#general-broadcasting-rules) in the documentation of NumPy:

> When operating on two arrays, NumPy compares their shapes element-wise. It starts with the trailing dimensions, and works its way forward. Two dimensions are compatible when

>    1. they are equal, or

>    2. one of them is 1

>If these conditions are not met, a `ValueError: frames are not aligned` exception is thrown, indicating that the arrays have incompatible shapes. The size of the resulting array is the maximum size along each dimension of the input arrays.

> Arrays do not need to have the same number of dimensions.


This is different from the built-in auto-threading in *Mathematica*. For example, *Mathematica* does not do this:

    {1, 2} + {{1, 2}, {2, 3}, {3, 4}}

I know that there is a [duplicate question][2]. But **there is no strong reason why *Mathematica* can't support such a technique**. At least, I think that it doesn't cause any contradictions to *Mathematica*'s existing list operation: we just need to check shape first and then "broadcast" it, which seems quite natural. And perhaps broadcasting can yield an efficiency boost because we don't need to transpose twice.

How could this technique be implemented in *Mathematica*?


  [1]: https://i.sstatic.net/JcKv1.png
  [2]: http://mathematica.stackexchange.com/questions/32188/how-to-extend-list-of-numbers-with-number-arithmetic-to-list-of-x-with-x-ari