(1..100).inject(&:+)

http://weblog.raganwald.com/2008/02/1100inject.html

by mightybyte • 18 years ago

34 62 18 years ago

weblog.raganwald.com

akehurst• 18 years ago

Why I hate ruby.

raganwald18• 18 years ago

The post? Or the quoted snippet of code?

;-)

mrtron3• 18 years ago

Since I don't use ruby either...I tried a web based interpreter.

   >> (1..100).inject(&:+)                                                 
   TypeError: wrong argument type Symbol (expected Proc)                   
     from (irb):1

I also am not a fan of doing things a thousand different obscure ways. I like doing things one way, and having that way highly optimized. Typing 10 characters or 20 characters doesn't impact my programming speed, I spend far more time thinking about how to do things the right way.

edit:

Ok, did his monkeypatch and it worked. You get 5050. So it is equiv to sum(range(101)) in python, and much less readable. I fail to see why this is a good thing.

Xichekolas4• 18 years ago

It won't work unless your web-based interpreter runs Ruby 1.9, or you also paste in his monkeypatch to the Symbol class.

raganwald18• 18 years ago

"I fail to see why this is a good thing."

Why what is a good thing? Why that line of code is a good thing? maybe it isn't, maybe arrays need a sum method, maybe you could just write:

(1..100).inject { |acc, n| acc + n }

...and get the same result. But the article has nothing to do with why that line of code is a good thing, it is about the fact that being able to modify the Symbol class in this manner is what makes a langauge like Ruby evolve from the bottom up.

So... do you think that is a good thing? Or a bad thing?

Xichekolas4• 18 years ago

Hahaha... Reg, it's like you wrote this in response to the recent article on Monkeypatching floating around here... Thanks! I enjoyed your writing as much as always... and it's especially timely today.

(http://news.ycombinator.com/item?id=123071 if you don't know to which I am referring.)

raganwald18• 18 years ago

Weeeel...

The truth is, I wrote the idea behind this a while back using String#to_proc to compare the way Ruby (roll your own) and Python (Guido decides) evolve. But considering I have no Python experience, I never published the post.

Then today, for some reason, I was thinking about Open Classes again :-)

spydez2• 18 years ago

Anyone want to explain that code to someone who doesn't know Ruby?

wvenable• 18 years ago

I'm not a ruby programmer and it's not immediately obvious what the result would be.

I know a pretty large number of languages to the point where, unless it's LISP, I can look at code in any language and have some idea of what it does. When a languages gets "so cool" that it's cryptic than I no longer see the benefit.

raganwald18• 18 years ago

Would (1..100).fold(&:+) be more obvious? How about (1..100).reduce(&:+)? If either one of those makes sense, perhaps it is a question of Matz choosing Smalltalk's names for methods (collect, select, detect, reject, inject).

Please let me know if changing the name of the method doesn't help.

Xichekolas4• 18 years ago

Sums the first 100 integers. You are basically injecting a function (plus in this case) between each element and evaluating it (to describe in very non-technical sense).

kcl2• 18 years ago

The same code in k:

    +/!100
  4950

Or if you insist on 1-indexing:

    +/1+!100
  5050

gregwebs3• 18 years ago

The way to write this in ruby without extending the symbol class is

  (1..100).inject { |acc, n| acc + n }

inject is a left fold or a reduce- it applies the function {acc + n} to each element in a list (or array) where acc is the result of the last function application.

For such a simple function, all we need is the knowledge that we are adding, which is contained in the symbol '+', representing the addition method. So Ideally we would like to write

  (1..100).inject( :+ )

The semicolon is how you tell ruby you are using a symbol. Yes, you can write a simple sum function, but the point is that this code is more flexible in a very powerful way- we can use other functions then inject and add.

Method calling in Ruby is actually message passing. So instead of calling

   1.+ 2   # => 3

You can say

  1.send( :+, 2 )   # => 3

So we are not trying to convert a symbol to a proc. What we are trying to do is continually send the message ':+' to inject's built in accumulator, with every member of the list (or array) as an argument.

In ruby, the brackets are like a function, but it is actually a closure of class Proc. You can convert a different class to a proc (if it supports it) by calling to_proc.

Ruby has a syntactic shortcut, '&' for converting to a proc. Normally it actually makes the code clearer because it is also used when passing Procs onto other methods, and is a nice type annotation. So we can hack this syntactic shortcut to create

  (1..100).inject( &:+ )

So by defining how '&' works by defining to_proc, we can make it create a closure (or Proc) which sends the ':+' symbol, along with any arguments that are yielded to the Proc. In this case, every value from (2..100) is yielded to the Proc. (1 will be the starting value of the accumulator.)

You can accomplish a lot of things with a closure, including this hack. But to me this shows that ruby was not designed as a functional programming language, and how by using Ruby's dangerous flexibility you can manage to warp it towards your needs.

After learning more languages, Ruby is starting to become pretty ugly to me, but somehow people keep managing to ignore all its faults, make little hacks like these, and be very productive with it.

raganwald18• 18 years ago

"After learning more languages, Ruby is starting to become pretty ugly to me, but somehow people keep managing to ignore all its faults, make little hacks like these, and be very productive with it."

When I first saw it, I wondered why anyone would want this irregular little language when they could just use Smalltalk or Scheme. An early rant asked why I have to know the difference between a block and a Proc: why the &^(%*)(& do I have to know when to use a block, when to use a Proc, and how to convert between them???

gregwebs3• 18 years ago

bloggified now:

http://thoughtfolder.com/2008-02-25-a-detailed-explanation-o...

gregwebs3• 18 years ago

actually, brackets represent a block. A block is converted to class Proc with '&'. If the object that '&' is used on is not a block, Ruby will first attempt to convert it into a Proc by calling to_proc

A Ruby block is always associated with a method, and cannot be captured in a variable without converting it back into a proc. This is done by 'removing' the '&'

  def return_block &block
    return block
  end

Readmore• 18 years ago

The reason I choose to continue with Ruby instead of moving to a language like Scheme has a lot to do with the community. There is so much activity in the Ruby and Rails communities that you can almost always find help with what you're trying to do, a library to make something easier, and great blogs with lots of little tricks. I just haven't seen that same level of community with languages like Scheme.

I'm not saying that you should choose your language based solely on the size of it's community (otherwise I would be pulling my hair out with Java) but the advanced features of Ruby, the expressiveness, and the community together make it a great place to be as a programmer.

henning2• 18 years ago

The VB.NET equivalent is Enumerable.Range(1, 100).Sum, which seems clearer to me. Why is this so impressive? If Visual Basic comes close to your beloved code snippet, it's probably not that big of a deal.

In real life, the answer is to know some math and realize that 1 + ... + n = n(n+1)/2, so the entire thing is pointless anyway.

(And if you want to add methods to a given class ad-hoc, you can do it statically with extension methods; Sum is an extension method.)

raganwald18• 18 years ago

The article does not claim that this is a good thing! It claims that the line of code says a lot about Ruby the language.

henning2• 18 years ago

That it's obsessed with obfuscatory, slow language constructs?

Darmani2• 18 years ago

Replace + in the Ruby with multiplication, or division, or boolean and, or even exponentiation, and show me the VB equivalent.

A digital-typewriter user will laugh at a PC user if all he sees the PC user doing is word processing.

ken2• 18 years ago

If you don't understand the difference between "a function that sums a list of integers" and "a function that accepts a function", then Joel has a pretty decent introduction you should read:

http://www.joelonsoftware.com/items/2006/08/01.html

Tichy• 18 years ago

Actually he is wrong about Java: people did add features to it without changing Java itself, for example AspectJ, and CLIB (I think is the name) that generates Java Code on the fly. Hibernate uses it, for example, to change the behaviour of the mapped Objects behind the scene.

raganwald18• 18 years ago

You would be amazed what people will do to Java. Just the other day I was reading something here about writing Java code using an Excel spread sheet. I'm pretty sure that wasn't in any of the JSRs.

kommissar2• 18 years ago

What does the &: do in Ruby?

raganwald18• 18 years ago

Actually, it's &(:+) not &:(+). The & takes its argument and converts from a Proc to a block. :+ is a symbol that implements the method #to_proc to give you a block that sums its receiver and its argument.

kommissar2• 18 years ago

Oh, cool. I knew the colon meant a Ruby symbol, but I did not know that you could use & to convert a Proc to block.

Darmani2• 18 years ago

Tokens beginning with a colon are literal Ruby symbols.

Prepending an ampersand before the last argument of a method call means that argument should be converted into a Proc and sent as a callback block to that method.

mattjones• 18 years ago

To some degree, using open classes is just how you write functions in Ruby.

Say there exists a class called Errors in some Ruby library. It doesn't have an each() method, but I'd like it to. Nobody would complain if I wrote a function each_error() which took an Errors object as an argument. Reopening the Errors class and giving it an each() method is the way you do that in Ruby, and it's not really any more dangerous.

foonamefoo• 18 years ago

Then lets say you packaged that up as a library. Another guy did the same thing, but it worked a little different. Now random code breaks.

ken2• 18 years ago

It turns out not to be a problem in practice. I could list the 20 things I hate most about Ruby and the 20 things I hate most about Rails, and this wouldn't make either list. I don't know that I've ever seen it happen.

And on the "technically, could it happen?" side, sure, it could. You can also write a Java library that, in weird cases, could screw up other Java libraries, but the Java folks (even as much as they love to try to keep you safe) don't care, either.

Besides, "each" is quite standard in Ruby. Defining it to mean something other than "call the proc with each element, in order" would be weirdbad, like a C++ programmer defining operator+ to mean subtraction. If you do something weirdbad like that, your library deserves to lose.

mynameishere3• 18 years ago

That sort of thing, for all of its doubtless glories, represents nothing so much as a contempt of the next programmer who has to deal with it. We're just moving bits and bytes around here, people. Please sum up the numbers and don't introduce any mysteries into the plumbing.

ALL OF THE REAL INNOVATION IN SOFTWARE IS RELATED TO THE PROBLEM DOMAIN AND NOT THE LANGUAGE

pg• 18 years ago

If you're saying something that's actually true, you don't need to use all uppercase.

mynameishere3• 18 years ago

ONE PLUS ONE EQUALS TWO.

God, I hope I didn't just rip open the space/time continuum.

mhartl• 18 years ago

I use Symbol#to_proc every day. I've never cared for the term "inject", though (or Python's "reduce", for that matter); I find SICP's "accumulate" much more mnemonic.

For what it's worth,

(1..100).to_a.sum

works in Rails, though

(1..100).sum

doesn't.

dusklight2• 18 years ago

So just out of curiosity .. what do you think is the most beautiful way to right the equivalent code in arc?

tel2• 18 years ago

In this case, the "equivalent" code isn't a line that produces the same result, but is instead a line that illustrates the dynamic culture of the given language's evolution.

For Arc, right now, practically every line is an equivalent.

raganwald18• 18 years ago

Thank you, exactly!!!

dusklight2• 18 years ago

Well okay let me elaborate on my question.

pg has stated that code brevity is one of the main design goals of arc. But what is pretty obvious is that code brevity is not the only consideration. It is desirable to be able to write very short code, but it should be readable as well. If you write very short code that is difficult for other people to read, that is bad enough. If you write very short code that ends up being difficult even for yourself to read -- then we have a problem.

The above ruby code snippet is a great example of code where reducing the length not only did not reduce readability, but actually increased it. I know some people have complained about it being obfuscated on this board. But to me, and I am sure to a number of other people on this board, it was easy to understand, intuitive even.

so .. in arc, what would be a similar way to create a list of numbers from 1 to 100, and to evaluate the sum of that list?

rontr2• 18 years ago

If Symbol#to_proc is so great, I'd like to see how it can elegantly express something that can't be hidden behind a simple library function. In any decent language the programmer would write "sum(1,100)". Even if the function's implementation in Python/Java/C++/Smalltalk/Lisp/etc required a few more characters, it wouldn't be a meaningful difference. Does Symbol#to_proc add any real power to Ruby or beyond enabling such linguistic brain teasers?

raganwald18• 18 years ago

Your question takes my breath away. May I quote you?

rontr2• 18 years ago

Only if you first answer it.

pchristensen• 18 years ago

Yes, a library function might be similar, but you would have to write it. s#t_p is already there, so even if it's not as clear, it's all you need.

Did you even read his article? The whole point was "Symbol#to_proc is a litmus test for how you view programming languages. I like it. What do you think of it?"

(1..100).inject(&:+)

Related Stories