[#36711] [Ruby 1.9 - Bug #4821][Open] Random Segfaults (in start_thread?) — Ivan Bortko <b2630639@...>

22 messages 2011/06/03

[#36730] [Ruby 1.9 - Feature #4824][Open] Provide method Kernel#executed? — Lazaridis Ilias <ilias@...>

56 messages 2011/06/04

[#36750] [Ruby 1.9 - Feature #4830][Open] Provide Default Variables for Array#each and other iterators — Lazaridis Ilias <ilias@...>

24 messages 2011/06/05

[#36785] [Ruby 1.9 - Feature #4840][Open] Allow returning from require — Rodrigo Rosenfeld Rosas <rr.rosas@...>

53 messages 2011/06/06
[#36811] Re: [Ruby 1.9 - Feature #4840][Open] Allow returning from require — Yusuke ENDOH <mame@...> 2011/06/07

Hello,

[#36799] [Ruby 1.9 - Feature #4845][Open] Provide Class#cb_object_instantiated_from_literal(object) — Lazaridis Ilias <ilias@...>

11 messages 2011/06/06

[#36834] [Ruby 1.9 - Feature #3905] rb_clear_cache_by_class() called often during GC for non-blocking I/O — Charles Nutter <headius@...>

10 messages 2011/06/08
[#36860] Re: [Ruby 1.9 - Feature #3905] rb_clear_cache_by_class() called often during GC for non-blocking I/O — Eric Wong <normalperson@...> 2011/06/08

Charles Nutter <headius@headius.com> wrote:

[#36863] Object#trust vs Object#taint — Aaron Patterson <aaron@...>

Hi,

16 messages 2011/06/08
[#36866] Re: Object#trust vs Object#taint — Yukihiro Matsumoto <matz@...> 2011/06/08

Hi,

[#36873] Re: Object#trust vs Object#taint — Aaron Patterson <aaron@...> 2011/06/09

On Thu, Jun 09, 2011 at 07:49:06AM +0900, Yukihiro Matsumoto wrote:

[#37071] [Ruby 1.9 - Feature #4877][Open] Unify Variable Expansion within Strings — Lazaridis Ilias <ilias@...>

12 messages 2011/06/12

[#37106] ruby core tutorials location — Roger Pack <rogerdpack2@...>

Hello all.

10 messages 2011/06/13
[#37107] Re: ruby core tutorials location — Jon <jon.forums@...> 2011/06/13

> Hello all.

[#37115] Re: ruby core tutorials location — Roger Pack <rogerdpack2@...> 2011/06/13

> Rather than adding links to source code, I would prefer the wikibooks link and others under a new Tutorials section of http://www.ruby-lang.org/en/documentation/ as well as adding http://ruby.runpaint.org/ to the existing Getting Started section.

[#37117] Re: ruby core tutorials location — Jon <jon.forums@...> 2011/06/13

> > Rather than adding links to source code, I would prefer the wikibooks link and others under a new Tutorials section of http://www.ruby-lang.org/en/documentation/ as well as adding http://ruby.runpaint.org/ to the existing Getting Started section.

[#37128] Re: ruby core tutorials location — Roger Pack <rogerdpack2@...> 2011/06/14

> I like what you're trying to do and see how great that tutorial connection from rdoc/yard could be, say, mixing with existing ruby-doc.org and rubydoc.info. ut I question embedding source links to info in which the info can easily grow outdated or abandoned as time passes. I also question the ongoing maintenance burdens.

[#37137] Re: ruby core tutorials location — Jon <jon.forums@...> 2011/06/14

> > I like what you're trying to do and see how great that tutorial connection from rdoc/yard could be, say, mixing with existing ruby-doc.org and rubydoc.info. ut I question embedding source links to info in which the info can easily grow outdated or abandoned as time passes. I also question the ongoing maintenance burdens.

[#37164] [Ruby 1.9 - Feature #4890][Open] Enumerable#lazy — Yutaka HARA <redmine@...>

30 messages 2011/06/16

[#37170] [Ruby 1.9 - Bug #4893][Open] Literal Instantiation breaks Object Model — Lazaridis Ilias <ilias@...>

61 messages 2011/06/16

[#37207] [Ruby 1.9 - Feature #4897][Open] Define Math::TAU and BigMath.TAU. The "true" circle constant, Tau=2*Pi. See http://tauday.com/ — Simon Baird <simon.baird@...>

43 messages 2011/06/17

[#37286] [Ruby 1.9 - Bug #4916][Open] [BUG] Segmentation fault - dyld: lazy symbol binding failed: Symbol not found: _ASN1_put_eoc — Hiroshi NAKAMURA <nakahiro@...>

9 messages 2011/06/22

[#37324] [Ruby 1.9 - Bug #4923][Open] [ext/openssl] test_ssl.rb: test_client_auth fails — Martin Bosslet <Martin.Bosslet@...>

19 messages 2011/06/23

[#37576] [Ruby 1.9 - Feature #4938][Open] Add Random.bytes [patch] — Marc-Andre Lafortune <ruby-core@...>

13 messages 2011/06/27

[#37612] [Ruby 1.9 - Bug #4941][Open] cannot load such file -- rubygems.rb (LoadError) — Lazaridis Ilias <ilias@...>

25 messages 2011/06/28

[ruby-core:37583] [Ruby 1.9 - Feature #3715] Enumerator#size and #size=

From: Hiroshi Nakamura <nakahiro@...>
Date: 2011-06-27 21:14:03 UTC
List: ruby-core #37583
Issue #3715 has been updated by Hiroshi Nakamura.

Target version changed from 1.9.3 to 1.9.x


----------------------------------------
Feature #3715: Enumerator#size and #size=
http://redmine.ruby-lang.org/issues/3715

Author: Marc-Andre Lafortune
Status: Open
Priority: Normal
Assignee: 
Category: core
Target version: 1.9.x


=begin
 It would be useful to be able to ask an Enumerator for the number of times it will yield, without having to actually iterate it.
 
 For example:
 
   (1..1000).to_a.permutation(4).size # => 994010994000  (instantly)
 
 It would allow nice features like:
 
   class Enumerator
     def with_progress
       return to_enum :with_progress unless block_given?
       out_of = size || "..."
       each_with_index do |obj, i|
         puts "Progress: #{i} / #{out_of}"
         yield obj
       end
       puts "Done"
     end
   end
 
   # To display the progress of any iterator, one can daisy-chain with_progress:
   20.times.with_progress.map do
     # do stuff here...
   end
 
 This would print out "Progress: 1 / 20", etc..., while doing the stuff.
 
 *** Proposed changes ***
 
 * Enumerator#size *
 
 call-seq:
   e.size          -> int, Float::INFINITY or nil
   e.size {block}  -> int
 
 Returns the size of the enumerator.
 The form with no block given will do a lazy evaluation of the size without going through the enumeration. If the size can not be determined then +nil+ is returned.
 The form with a block will always iterate through the enumerator and return the number of times it yielded.
 
   (1..100).to_a.permutation(4).size # => 94109400
   loop.size # => Float::INFINITY
 
   a = [1, 2, 3]
   a.keep_if.size         # => 3
   a                      # => [1, 2, 3]
   a.keep_if.size{false}  # => 3
   a                      # => []
 
   [1, 2, 3].drop_while.size             # => nil
   [1, 2, 3].drop_while.size{|i| i < 3}  # => 2
 
 
 * Enumerator#size= *
 
 call-seq:
   e.size = sz
 
 Sets the size of the enumerator. If +sz+ is a Proc or a Method, it will be called each time +size+ is requested, otherwise +sz+ is returned.
 
   first = [1, 2, 3]
   second = [4, 5]
   enum = Enumerator.new do |y|
     first.each{|o| y << o}
     second.each{|o| y << o}
   end
   enum.size    # => nil
   enum.size = ->(e){first.size + second.size}
   enum.size    # => 5
   first << 42
   enum.size    # => 6
 
 * Kerne#to_enum / enum_for *
 
 The only other API change is for #to_enum/#enum_for, which can accept a block for size calculation:
 
   class Date
     def step(limit, step=1)
       unless block_given?
         return to_enum(:step, limit, step){|date| (limit - date).div(step) + 1}
       end
       # ...
     end
   end
 
 *** Implementation ***
 
 I implemented the support for #size for most builtin enumerator producing methods (63 in all).
 
 It is broken down in about 20 commits: http://github.com/marcandre/ruby/commits/enum_size
 
 It begins with the implementation of Enumerator#size{=}: http://github.com/marcandre/ruby/commit/a92feb0
 
 A combined patch is available here: http://gist.github.com/535974
 
 Still missing are Dir#each, Dir.foreach, ObjectSpace.each_object, Range#step, Range#each, String#upto, String#gsub, String#each_line.
 
 The enumerators whose #size returns +nil+ are:
   Array#{r}index, {take|drop}_while
   Enumerable#find{_index}, {take|drop}_while
   IO: all methods
 
 *** Notes ***
 * Returning +nil+ *
 
 I feel it is best if IO.each_line.size and similar return +nil+ to avoid side effects.
 
 We could have Array#find_index.size return the size of the array with the understanding that this is the maximum number of times the enumerator will yield. Since a block can always contain a break statement, size could be understood as a maximum anyways, so it can definitely be argued that the definition should be the maximum number of times.
 
 * Arguments to size proc/lambda *
 
 My implementation currently passes the object that the enumerator will call followed with any arguments given when building the enumerator.
 
 If Enumerator had getters (say Enumerator#base, Enumerator#call, Enumerator#args, see feature request #3714), passing the enumerator itself might be a better idea.
 
 * Does not dispatch through name *
 
 It might be worth noting that the size dispatch is decided when creating the enumerator, not afterwards in function of the class & method name:
 
 [1,2,3].permutation(2).size # => 6
 [1,2,3].to_enum(:permutation, 2).size # => nil
 
 * Size setter *
 
 Although I personally like the idea that #size= can accept a Proc/Lambda for later call, this has the downside that there is no getter, i.e. no way to get the Proc/Lambda back. I feel this is not an issue, but an alternative would be to have a #size_proc and #size_proc= setters too (like Hash).
 
 I believe this addresses feature request #2673, although maybe in a different fashion. http://redmine.ruby-lang.org/issues/show/2673
=end



-- 
http://redmine.ruby-lang.org

In This Thread

Prev Next