# \<\< operator for arrays

**URL:** <https://discourse.julialang.org/t/operator-for-arrays/17089>\
**Category:** Internals & Design\
**Created:** [November 2, 2018, 3:21pm UTC](https://discourse.julialang.org/t/operator-for-arrays/17089 "2018-11-02T15:21:03Z")\
**Posts on this page:** 20\
**Page:** 1

<div class="post-metadata">

**Author:** ![RaulDurand](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/rauldurand/32/2044_2.png) [@RaulDurand](https://discourse.julialang.org/u/RaulDurand)\
**Post date:** [November 2, 2018, 3:21pm UTC](https://discourse.julialang.org/t/operator-for-arrays/17089/1 "2018-11-02T15:21:04Z")

</div>

Any chance to overload operator \<\< (or any other) to mean push! as a syntactic sugar?  
e.g.

```julia
a = [1,2,3]
a << factorial(5) # a = [1,2,3,120]

```

Seems to be clearer and simpler than

```julia
push!(a, factorial(5))

```

---

<div class="post-metadata">

**Author:** ![kristoffer.carlsson](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/kristoffer.carlsson/32/22_2.png) [@kristoffer.carlsson](https://discourse.julialang.org/u/kristoffer.carlsson)\
**Post date:** [November 2, 2018, 3:26pm UTC](https://discourse.julialang.org/t/operator-for-arrays/17089/2 "2018-11-02T15:26:58Z")

</div>

```julia
f(x) = x << 3

```

What does this code do when you read it in a file? How would you document `f`?

Taking from another language that abused `<<`:

> **[C++ Core Guidelines](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Ro-equivalent)**
>
> The C++ Core Guidelines are a set of tried-and-true guidelines, rules, and best practices about coding in C++

> ### C.163: Overload only for operations that are roughly equivalent
> 
> **Reason** Having the same name for logically different functions is confusing and leads to errors when using generic programming. Example \> Consider:
> 
> ```julia
> void open_gate(Gate& g); // remove obstacle from garage exit lane
> void fopen(const char* name, const char* mode); // open file
> 
> ```
> 
> The two operations are fundamentally different (and unrelated) so it is good that their names differ.
> 
> ```julia
> void open(Gate& g); // remove obstacle from garage exit lane
> void open(const char* name, const char* mode ="r"); // open file
> 
> ```
> 
> The two operations are still fundamentally different (and unrelated) but the names have been reduced to their (common) minimum, opening opportunities for confusion.

---

<div class="post-metadata">

**Author:** ![RaulDurand](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/rauldurand/32/2044_2.png) [@RaulDurand](https://discourse.julialang.org/u/RaulDurand)\
**Post date:** [November 2, 2018, 3:37pm UTC](https://discourse.julialang.org/t/operator-for-arrays/17089/3 "2018-11-02T15:37:08Z")

</div>

I agree. May be another operator could fit.

---

<div class="post-metadata">

**Author:** ![laborg](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/laborg/32/5474_2.png) [@laborg](https://discourse.julialang.org/u/laborg)\
**Post date:** [November 2, 2018, 3:41pm UTC](https://discourse.julialang.org/t/operator-for-arrays/17089/4 "2018-11-02T15:41:16Z")

</div>

My initial thought was: yeah, an operator for this would be cool, but then remembered writing Scala code and how too many operators can have a downside: [What do all of Scala's symbolic operators mean? - Stack Overflow](https://stackoverflow.com/questions/7888944/what-do-all-of-scalas-symbolic-operators-mean))

---

<div class="post-metadata">

**Author:** ![NiclasMattsson](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/niclasmattsson/32/21988_2.png) [@NiclasMattsson](https://discourse.julialang.org/u/NiclasMattsson)\
**Post date:** [November 2, 2018, 3:55pm UTC](https://discourse.julialang.org/t/operator-for-arrays/17089/5 "2018-11-02T15:55:37Z")

</div>

Why not just DIY using arrow operators?

```julia
julia> ↦(x,a) = pushfirst!(a::AbstractArray,x)
↦ (generic function with 1 method)

julia> ↤(a,x) = push!(a::AbstractArray,x)
↤ (generic function with 1 method)

julia> 3 ↦ [1,2]
3-element Array{Int64,1}:
 3
 1
 2

julia> [1,2] ↤ 3         
3-element Array{Int64,1}:
 1                       
 2                       
 3                       

```

---

<div class="post-metadata">

**Author:** ![StefanKarpinski](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/stefankarpinski/32/24_2.png) [@StefanKarpinski](https://discourse.julialang.org/u/StefanKarpinski)\
**Post date:** [November 2, 2018, 5:28pm UTC](https://discourse.julialang.org/t/operator-for-arrays/17089/6 "2018-11-02T17:28:46Z")

</div>

Operators don’t give any hint that they are mutating which is not ideal.

---

<div class="post-metadata">

**Author:** ![laborg](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/laborg/32/5474_2.png) [@laborg](https://discourse.julialang.org/u/laborg)\
**Post date:** [November 2, 2018, 5:29pm UTC](https://discourse.julialang.org/t/operator-for-arrays/17089/7 "2018-11-02T17:29:18Z")

</div>

> [@NiclasMattsson](#):
>
> Why not just DIY using arrow operators?

I think its fare to discuss the possibility for a generally accepted operators for specific base functions. If everybody started DIYing operators for base functions, then reading unfamiliar Julia code would become cumbersome.

---

<div class="post-metadata">

**Author:** ![StefanKarpinski](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/stefankarpinski/32/24_2.png) [@StefanKarpinski](https://discourse.julialang.org/u/StefanKarpinski)\
**Post date:** [November 2, 2018, 6:20pm UTC](https://discourse.julialang.org/t/operator-for-arrays/17089/8 "2018-11-02T18:20:20Z")

</div>

Why does pushing to an array need an operator?

---

<div class="post-metadata">

**Author:** ![kristoffer.carlsson](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/kristoffer.carlsson/32/22_2.png) [@kristoffer.carlsson](https://discourse.julialang.org/u/kristoffer.carlsson)\
**Post date:** [November 2, 2018, 6:23pm UTC](https://discourse.julialang.org/t/operator-for-arrays/17089/9 "2018-11-02T18:23:43Z")

</div>

Can we use 🍾 for `pop!`?

---

<div class="post-metadata">

**Author:** ![simonbyrne](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/simonbyrne/32/19_2.png) [@simonbyrne](https://discourse.julialang.org/u/simonbyrne)\
**Post date:** [November 2, 2018, 6:26pm UTC](https://discourse.julialang.org/t/operator-for-arrays/17089/10 "2018-11-02T18:26:36Z")

</div>

> [@laborg](#):
>
> If everybody started DIYing operators for base functions, then reading unfamiliar Julia code would become cumbersome.

Or it would look like APL.

---

<div class="post-metadata">

**Author:** ![Liso](https://avatars.discourse-cdn.com/v4/letter/l/898d66/32.png) [@Liso](https://discourse.julialang.org/u/Liso)\
**Post date:** [November 2, 2018, 6:29pm UTC](https://discourse.julialang.org/t/operator-for-arrays/17089/11 "2018-11-02T18:29:15Z")

</div>

Are you sure that `open` in Julia open only file?

---

<div class="post-metadata">

**Author:** ![StefanKarpinski](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/stefankarpinski/32/24_2.png) [@StefanKarpinski](https://discourse.julialang.org/u/StefanKarpinski)\
**Post date:** [November 2, 2018, 6:34pm UTC](https://discourse.julialang.org/t/operator-for-arrays/17089/12 "2018-11-02T18:34:40Z")

</div>

Also command objects; those are not unrelated operations.

---

<div class="post-metadata">

**Author:** ![kristoffer.carlsson](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/kristoffer.carlsson/32/22_2.png) [@kristoffer.carlsson](https://discourse.julialang.org/u/kristoffer.carlsson)\
**Post date:** [November 2, 2018, 6:35pm UTC](https://discourse.julialang.org/t/operator-for-arrays/17089/13 "2018-11-02T18:35:28Z")

</div>

I am sure it doesn’t open the gate to the garage though 😉

---

<div class="post-metadata">

**Author:** ![RaulDurand](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/rauldurand/32/2044_2.png) [@RaulDurand](https://discourse.julialang.org/u/RaulDurand)\
**Post date:** [November 2, 2018, 9:21pm UTC](https://discourse.julialang.org/t/operator-for-arrays/17089/14 "2018-11-02T21:21:10Z")

</div>

Well, there is a list of mutating operators: `+=, -=, *=`, etc.  
Some similar operators (using =) are not: `<=, >=`

On the other hand, I think that this combination is not used jet: `+>, <+`

```julia
a <+ factorial(5) # a = [1,2,3,120]

```

The less sign (\<) gives some notion of direction and the + sign some notion of addition.

Well, this is just an idea and probably will stay as that because the reasons already presented.

---

<div class="post-metadata">

**Author:** ![rdeits](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/rdeits/32/286_2.png) [@rdeits](https://discourse.julialang.org/u/rdeits)\
**Post date:** [November 2, 2018, 9:33pm UTC](https://discourse.julialang.org/t/operator-for-arrays/17089/15 "2018-11-02T21:33:31Z")

</div>

Actually, neither `+=` nor `*=` nor any of the similar operators is mutating in general. They all create a new value which is independent of the previous values because:

```julia
x += y

```

is transformed into

```julia
x = x + y

```

which creates a new value which just happens to also be called `x`.

This is a common misconception about Julia because those operators _are_ mutating in many languages, like Python for example.

---

<div class="post-metadata">

**Author:** ![Liso](https://avatars.discourse-cdn.com/v4/letter/l/898d66/32.png) [@Liso](https://discourse.julialang.org/u/Liso)\
**Post date:** [November 3, 2018, 9:04am UTC](https://discourse.julialang.org/t/operator-for-arrays/17089/16 "2018-11-03T09:04:12Z")

</div>

> [@kristoffer.carlsson](#):
>
> ```julia
> f(x) = x << 3
> 
> ```
> 
> What does this code do when you read it in a file? How would you document `f` ?

BTW `f(a, b) = a * b` could mean multiply (numbers, arrays) or concatenate (strings) or append (char to string) or combine (two chars to string) or logical and for booleans or …

---

<div class="post-metadata">

**Author:** ![y4lu](https://avatars.discourse-cdn.com/v4/letter/y/47e85d/32.png) [@y4lu](https://discourse.julialang.org/u/y4lu)\
**Post date:** [November 3, 2018, 10:43am UTC](https://discourse.julialang.org/t/operator-for-arrays/17089/17 "2018-11-03T10:43:53Z")

</div>

```julia
julia> <| = push!;
julia> x = []
julia> x <| 1

```

This next ones a bit suss

```julia
julia> (x$$) = print(x); 
julia> 1 $ 2

```

There is a good range of special chars from ‘z’ + 40 to 120 that you can get at with `clipboard()`, eg ‘«’ is ‘z’+49

---

<div class="post-metadata">

**Author:** ![StefanKarpinski](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/stefankarpinski/32/24_2.png) [@StefanKarpinski](https://discourse.julialang.org/u/StefanKarpinski)\
**Post date:** [November 3, 2018, 1:36pm UTC](https://discourse.julialang.org/t/operator-for-arrays/17089/18 "2018-11-03T13:36:29Z")

</div>

Those are all a form of multiplication. Concatenation is the group operation in the non-commutative free group over letters. I got to explain this recently to an algebraist and she was delighted.

---

<div class="post-metadata">

**Author:** ![Liso](https://avatars.discourse-cdn.com/v4/letter/l/898d66/32.png) [@Liso](https://discourse.julialang.org/u/Liso)\
**Post date:** [November 4, 2018, 5:41am UTC](https://discourse.julialang.org/t/operator-for-arrays/17089/19 "2018-11-04T05:41:25Z")

</div>

> [@StefanKarpinski](#):
>
> Those are all a form of multiplication.

And opening gate is not a form of opening?

---

<div class="post-metadata">

**Author:** ![StefanKarpinski](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/stefankarpinski/32/24_2.png) [@StefanKarpinski](https://discourse.julialang.org/u/StefanKarpinski)\
**Post date:** [November 4, 2018, 3:48pm UTC](https://discourse.julialang.org/t/operator-for-arrays/17089/20 "2018-11-04T15:48:35Z")

</div>

Sure, that wasn’t my example. If you think that gate opening fits into the meaning of the generic `open` function, go to town. The real litmus test is if it’s plausible that one might be able to write useful generic code that abstracts over file opening and gate opening. It’s common to do such abstraction over files versus processes which is why they share a generic function. It’s pretty unclear if gate opening satisfies that criterion but I suppose it’s possible. On the other hand, it’s 100% clear that bit shifting and array appending do not fit into a common abstraction.

[Next page](https://discourse.julialang.org/t/operator-for-arrays/17089.md?page=2)