Ruby adds experimental support for rightward assignments • Hacker News Board

Re: Ruby adds experimental support for rightward assignments

#71

Post by bachmeier » Thu, Sep 10, 2020, 8:49 PM UTC

throwaway4007 wrote: post #51

>R language also has a similar way of doing this 42 -> age. Ah yes, the R language, a model of clarity, beauty and lightness in the world of programming languages. Truly an example to follow. (And it's not like anyone ever uses that "feature" in the R world either.)

shrug

I've used it. The overloading of the equals sign is something that has never made sense for assignment. (Seriously, it's hard to intentionally come up with dumber notation than x = x+1.) I do use -> sometimes. It's more natural to do the evaluation and then figure out where you're going to store the result (particularly when you're programming).

This is minor as these things go. Definitely not a big deal one way or the other.

Re: Ruby adds experimental support for rightward assignments

#72

Post by e12e » Thu, Sep 10, 2020, 8:50 PM UTC

Uh.. I'm not sure I like this, in a language that already has a similar boolean operator (although I suppose that goes for all uses of such "arrow" operators). But still:

  a = 2
  b = 1
  b >= a # false
  b >= a => a # assign false to a?
  b => a # assign 1 to a?

Re: Ruby adds experimental support for rightward assignments

#73

Post by lacker » Thu, Sep 10, 2020, 8:52 PM UTC

This is true to Ruby's Perl heritage. There is more than one way to do everything, even the most basic of operations.

Quiz: what does the following Ruby code do?

  a = b => c = d

Re: Ruby adds experimental support for rightward assignments

#74

Post by Izkata » Thu, Sep 10, 2020, 8:54 PM UTC

Someone wrote: post #53

syspec wrote: post #39

Earlier quoted context omitted.

Not to me, and other people who use Ruby sparingly

I’m not sure. In shell, I think makejunk | grep foo | tail -4 > fourthings is more popular than > fourthings makejunk | grep foo | tail -4 Having said that, I don’t understand why you would add this, but then, I don’t understand the popularity of ruby or other languages that think adding alternative ways to do things most of the time is a good thing.

In shell outside of file manipulation,

  fourthings=$(makejunk | grep foo | tail -4)

Re: Ruby adds experimental support for rightward assignments

#75

Post by drchopchop » Thu, Sep 10, 2020, 8:55 PM UTC

So, a = b becomes equivalent to b => a.

However, you already construct hashes like hash = {:a => b}.

Perhaps we can also add reverse hash construction like hash = {b = a} for consistency (and additional madness)

Re: Ruby adds experimental support for rightward assignments

#76

Post by ww520 » Thu, Sep 10, 2020, 9:03 PM UTC

I like it. The next step is piping result forward.

   1.2 + 2 | double | abs => result

Re: Ruby adds experimental support for rightward assignments

#77

Post by transfire » Thu, Sep 10, 2020, 9:06 PM UTC

I wish they pay more attention to real issues and potentials. e.g. The Refinement design is half-baked -- Can't refine module methods, can't DRYly reuse monkey patch code as refinements...

Re: Ruby adds experimental support for rightward assignments

#78

Post by dgellow » Thu, Sep 10, 2020, 9:08 PM UTC

But... why?

Re: Ruby adds experimental support for rightward assignments

#79

Post by jcheng » Thu, Sep 10, 2020, 9:20 PM UTC

toxik wrote: post #24

jcheng wrote: post #4

Rightward assignment is pretty strongly discouraged in the R community, due to the effect it has of burying the lede. That said, I always felt the same about Ruby’s inline if/unless (`puts "still working" unless done`) so maybe it will have a better reception in this community.

Interesting, that it became discouraged. Probably won’t make it into Ruby proper then. I don’t fault them for experiment.

Actually, this is a pretty good reason, and it's straight from the source (creator of S, the predecessor of R): https://stackoverflow.com/a/51548423/139922

> When you type a long expression only to remember at the end that it would be a good idea to save the result, a right-hand arrow allows you to perform an assignment without retyping the line.

(I don't do this personally, though. I just run the expression and then my next command is `x <- .Last.value`)

Re: Ruby adds experimental support for rightward assignments

#80

Post by spc476 » Thu, Sep 10, 2020, 9:20 PM UTC

ultrarunner wrote: post #48

hhsnopek wrote: post #2

[question]: Is the main benefit of "Rightward assignments" readability and does this provide more benefits?

I think I would use this if I were writing a cpu emulator in Ruby (which I wouldn't). It mirrors assembly, but I'm not sure that's a good thing.

It depends upon the assembly language. Intel defines its opcodes as `dest,src` and Motorola did `src,dest`.