I have code like this
my_enum = [1,2].to_enum
puts my_emum.next
and it doesn't work
I understand that the enumerator is available in Ruby 1.8 as an extension. How to install it?(I'm new to ruby)
If I fix the typo it works fine. irb session follows.
>> my_enum = [1,2].to_enum
=> #<Enumerable::Enumerator:0xb79dd700>
>> puts my_enum.next
1
>> puts my_enum.next
2
Tested in
>> VERSION
=> "1.8.7"
What version of ruby 1.8 are you running? This matters significantly.
(Also note that you have a typo in "my_emum").
In Ruby 1.8.6 , there is no "next" method for enums, just "each".
Example:
my_enum = [1,2].to_enum
my_enum.each do |e|
puts e
end
In Ruby 1.8.7, "next" is supported.
As mentioned in this answer to a different question, in Ruby 1.8.6, you can do
require 'enumerator'
6.enum_for(:times).map {...}
But I don't know if it'll allow you to do my_enum.next.
I think the documentation is at http://ruby-doc.org/stdlib/libdoc/enumerator/rdoc/ , but it seems to be down right now.
Related
Consider the following code:
module M
def original ; puts __callee__ ; end
alias_method :aliased, :original
end
class A
include M
end
A.new.original
#⇒ original
A.new.aliased
#⇒ aliased
The above code runs perfectly fine in Ruby 2.1 and returns the actual method name, as it is supposed to be done by Kernel#__callee__.
Surprisingly enough, the code above does not work as expected in Ruby 2.3.1:
A.new.original
#⇒ original
A.new.aliased
#⇒ original
Is this a desired behaviour I failed to find in release notes, or is it a bug in MRI for 2.3? The same happens for alias.
PS I have created an issue https://bugs.ruby-lang.org/issues/12761
This code broke on Ruby 2.1
class Test
def to_s()
"hi"
end
end
puts [Test.new(), Test.new()].to_s
Ruby 1.9.3:
$ ruby --version
ruby 1.9.3p484 (2013-11-22 revision 43786) [x86_64-linux]
$ /opt/chef/embedded/bin/ruby test.rb
[hi, hi]
Ruby 2.1:
$ ruby --version
ruby 2.1.4p265 (2014-10-27 revision 48166) [x86_64-linux]
$ ruby test.rb
[#<Test:0x000000022ac400>, #<Test:0x000000022ac3d8>]
Is this documented somewhere? How can the old behavior be preserved?
Your code:
puts [Test.new(), Test.new()].to_s
is a questionable use of Array.to_s. Instead I'd use:
puts [Test.new(), Test.new()].map(&:to_s)
While I can see that the first use makes sense, the second use makes more sense and should work in any version of Ruby.
On ruby 2.1.5:
class Test
def to_s
"hi"
end
alias inspect to_s # add this line
end
puts [Test.new, Test.new].to_s
#=> [hi, hi]
This seems like a bug to me. If it is intended behavior, that is really annoying.
You don't need to_s. puts does the work for you
puts [Test.new(), Test.new()]
# hi
# hi
If you want the brackets, that's what inspect is for (in which case it makes sense that you would need to define Test#inspect).
I have a Ruby script that iterates over each line of a text file.
In Ruby 1.8.* using content.each do |line| works fine, but in Ruby 1.9.* that does not work, and I need to use content.each_line do |line|.
Since this script will be used by several different people, I need to be able to use the right method depending on their version of Ruby.
Is there a way to do this?
The global constant RUBY_VERSION contains the version of the currently running Ruby. So this script will do what you want:
if RUBY_VERSION < "1.9.2"
# code for 1.8.7
else
# code for 1.9.2+
end
If the inner code of the each_line is equal with 1.8.* and 1.9.*, the following approach is more DRY:
each_selector = RUBY_VERSION < "1.9.2" ? :each : :each_line
content.send(each_selector) do | line|
# ...
end
I am working with the method mm. In ruby 1.9.2 it behaves weird, instead of the expected result 1.9.2=>10 I am getting
ELSE **
1.9.2=>8
Any idea of what is going on?
class A
def mm(data)
begin
send_len = data
return send_len
rescue Exception
STDOUT.write("Rescue *#{$!}*\n")
else
STDOUT.write("ELSE *#{$!}*\n")
end
end
end # class A
a = A.new
print "#{RUBY_VERSION}=>#{a.mm(10)}\n"
With 1.8.7 I get the expected result:
1.8.7=>10
It's an open bug in Ruby. There is a discussion, though, whether it should behave like it behaved in 1.8 or as it does in 1.9.
Matz, the author of Ruby, believes that it should behave as in 1.8.
I need to grab the name of the lexically enclosing method in Ruby 1.8; e.g.
def foo
this_method = __callee__ # => 'foo'
end
The above code is valid in Ruby 1.9, but fails in 1.8, since __callee__ was introduced in 1.9.
Any suggestions for doing this in 1.8? Kernel#caller looked promising, but seems to give me the call stack starting with the caller of the method, not the method itself.
I guess I could throw an exception, catch it, and grab the first element in the Exception#backtrace array, but my gut tells me that will be slow.
On Ruby 1.8.7 there is the __method__, not sure about 1.8.6.
Anyway, You can monkey patch the Kernel module:
module Kernel
# Defined in ruby 1.9
unless defined?(__callee__)
def __callee__
caller[0] =~ /`([^']*)'/ and $1
end
end
end
Have you checked whether the "backports" gem has it?