hamster 0.1.15 → 0.1.16

data/History.rdoc

@@ -1,3 +1,19 @@
+=== 0.1.16 / 2009-12-30
+
+* Ensure streams cache results.
+
+* Ensure lists don't blow the stack.
+
+* List#entries is now an alias for List#to_a.
+
+* Implement List#to_list.
+
+* Implement List#one?.
+
+* Set#to_a is now aliased as #entries.
+
+* Implement List#minimum (aliased as #min) and List#maximum (aliased as #max).
+
 === 0.1.15 / 2009-12-15
 
 * Implemented IO#to_list.

data/README.rdoc

@@ -1,6 +1,6 @@
 = Hamster
 
-Hamster started out as an implementation of Hash Array Mapped Hashes (HAMT) for Ruby (see http://lamp.epfl.ch/papers/idealhashtrees.pdf) and has since expanded to include implementations of other Persistent Data Structures (see http://en.wikipedia.org/wiki/Persistent_data_structure) such as Sets, Lists, Stacks, etc.
+Hamster started out as an implementation of Hash Array Mapped Trees (HAMT) for Ruby (see http://lamp.epfl.ch/papers/idealhashtrees.pdf) and has since expanded to include implementations of other Persistent Data Structures (see http://en.wikipedia.org/wiki/Persistent_data_structure) such as Sets, Lists, Stacks, etc.
 
 == Huh?
 
@@ -73,9 +73,9 @@ versus
 
   (1..10000).each { |i| hash[i] }  # => 0.001s
 
-Impressive huh? What's even better is--or worse depending on your perspective--is that after all that, the native <tt>Hash</tt> version still isn't thread-safe and still requires some synchronisation around it slowing it down even further!
+Impressive huh? What's even better is--or worse depending on your perspective--is that after all that, the native <tt>Hash</tt> version still isn't thread-safe and still requires some synchronisation around it slowing it down even further.
 
-The <tt>Hamster::Hash</tt> version on the other hand was unchanged from the original whilst remaining inherently thread-safe, and 3 orders of magnitude faster!
+The <tt>Hamster::Hash</tt> version on the other hand was unchanged from the original whilst remaining inherently thread-safe, and 3 orders of magnitude faster.
 
 == Sure, but as you say, you still need synchronisation so why bother with the copying?
 
@@ -129,9 +129,9 @@ Besides <tt>Hamster.list</tt> there are other ways to construct lists:
 
 You also get <tt>Enumerable#to_list</tt> so you can slowly transition from built-in collection classes to Hamster.
 
-And finally, you also <tt>IO#to_list</tt> allowing you to lazily processes huge files. For example, imagine the following code to process a 10MB file:
+And finally, you get <tt>IO#to_list</tt> allowing you to lazily processes huge files. For example, imagine the following code to process a 100MB file:
 
-  File.open("my_10_mb_file.txt") do |io|
+  File.open("my_100_mb_file.txt") do |io|
     lines = []
     io.each_line do |line|
       break if lines.size == 10
@@ -141,14 +141,14 @@ And finally, you also <tt>IO#to_list</tt> allowing you to lazily processes huge
 
 How many times/how long did you read the code before it became apparent what the code actually did? Now compare that to the following:
 
-  File.open("my_10_mb_file.txt") do |io|
-    io.map(&:chomp).map(&:downcase).map(&:reverse)[0, 10]
+  File.open("my_100_mb_file.txt") do |io|
+    io.map(&:chomp).map(&:downcase).map(&:reverse).take(10)
   end
 
-Unfortunately, though the second example reads nicely, it takes around 3 seconds to run--compared with 0.033 seconds for the first--even though we're only interested in the first 10 lines! However, using a little <tt>#to_list</tt> magic, we can get the running time down to 0.033 seconds!
+Unfortunately, though the second example reads nicely, it takes around 13 seconds to run (compared with 0.033 seconds for the first) even though we're only interested in the first 10 lines! However, using a little <tt>#to_list</tt> magic, we can get the running time back down to 0.033 seconds!
 
-  File.open("my_10_mb_file.txt") do |io|
-    puts io.to_list.map(&:chomp).map(&:downcase).map(&:reverse).take(10)
+  File.open("my_100_mb_file.txt") do |io|
+    io.to_list.map(&:chomp).map(&:downcase).map(&:reverse).take(10)
   end
 
 How is this even possible? It's possible because <tt>IO#to_list</tt> creates a lazy list whereby each line is only ever read and processed as needed, in effect converting it to the first example without all the syntactic, imperative, noise.

data/lib/hamster/core_ext/enumerable.rb

@@ -7,7 +7,7 @@ module Hamster
     module Enumerable
 
       def to_list
-        Hamster.list(self)
+        Hamster.list(*self)
       end
 
     end

data/lib/hamster/core_ext/enumerable.rbc

@@ -0,0 +1,481 @@
+!RBIX
+0
+x
+M
+1
+n
+n
+x
+10
+__script__
+i
+69
+5
+7
+0
+60
+44
+46
+1
+1
+14
+42
+2
+3
+7
+4
+61
+46
+5
+2
+13
+42
+2
+6
+12
+7
+7
+12
+7
+8
+12
+61
+12
+46
+9
+4
+14
+45
+7
+14
+42
+2
+10
+7
+11
+61
+46
+5
+2
+13
+42
+2
+12
+12
+7
+7
+12
+7
+13
+12
+61
+12
+46
+9
+4
+14
+45
+7
+14
+2
+11
+I
+6
+I
+0
+I
+0
+I
+0
+n
+p
+14
+s
+12
+hamster/list
+x
+7
+require
+x
+8
+Rubinius
+n
+x
+7
+Hamster
+x
+11
+open_module
+n
+x
+15
+__module_init__
+M
+1
+n
+n
+x
+7
+Hamster
+i
+31
+5
+62
+42
+0
+1
+7
+2
+61
+46
+3
+2
+13
+42
+0
+4
+12
+7
+5
+12
+7
+6
+12
+61
+12
+46
+7
+4
+14
+45
+5
+11
+I
+6
+I
+0
+I
+0
+I
+0
+n
+p
+8
+x
+8
+Rubinius
+n
+x
+7
+CoreExt
+x
+11
+open_module
+n
+x
+15
+__module_init__
+M
+1
+n
+n
+x
+7
+CoreExt
+i
+31
+5
+62
+42
+0
+1
+7
+2
+61
+46
+3
+2
+13
+42
+0
+4
+12
+7
+5
+12
+7
+6
+12
+61
+12
+46
+7
+4
+14
+45
+5
+11
+I
+6
+I
+0
+I
+0
+I
+0
+n
+p
+8
+x
+8
+Rubinius
+n
+x
+10
+Enumerable
+x
+11
+open_module
+n
+x
+15
+__module_init__
+M
+1
+n
+n
+x
+10
+Enumerable
+i
+17
+5
+62
+42
+0
+1
+7
+2
+7
+3
+61
+63
+45
+4
+46
+5
+4
+11
+I
+5
+I
+0
+I
+0
+I
+0
+n
+p
+6
+x
+8
+Rubinius
+n
+x
+7
+to_list
+M
+1
+n
+n
+x
+7
+to_list
+i
+10
+42
+0
+1
+5
+33
+1
+48
+2
+0
+11
+I
+3
+I
+0
+I
+0
+I
+0
+n
+p
+3
+x
+7
+Hamster
+n
+x
+4
+list
+p
+5
+I
+0
+I
+9
+I
+0
+I
+a
+I
+a
+x
+72
+/Users/haruki_zaemon/Projects/hamster/lib/hamster/core_ext/enumerable.rb
+p
+0
+x
+17
+method_visibility
+x
+15
+add_defn_method
+p
+3
+I
+2
+I
+9
+I
+11
+x
+72
+/Users/haruki_zaemon/Projects/hamster/lib/hamster/core_ext/enumerable.rb
+p
+0
+x
+13
+attach_method
+p
+3
+I
+2
+I
+7
+I
+1f
+x
+72
+/Users/haruki_zaemon/Projects/hamster/lib/hamster/core_ext/enumerable.rb
+p
+0
+x
+13
+attach_method
+p
+3
+I
+2
+I
+5
+I
+1f
+x
+72
+/Users/haruki_zaemon/Projects/hamster/lib/hamster/core_ext/enumerable.rb
+p
+0
+x
+13
+attach_method
+n
+x
+10
+Enumerable
+n
+M
+1
+n
+n
+x
+10
+Enumerable
+i
+15
+5
+62
+5
+42
+0
+1
+40
+2
+40
+3
+44
+46
+4
+1
+11
+I
+2
+I
+0
+I
+0
+I
+0
+n
+p
+5
+x
+7
+Hamster
+n
+x
+7
+CoreExt
+x
+10
+Enumerable
+x
+7
+include
+p
+3
+I
+2
+I
+15
+I
+f
+x
+72
+/Users/haruki_zaemon/Projects/hamster/lib/hamster/core_ext/enumerable.rb
+p
+0
+p
+7
+I
+0
+I
+1
+I
+9
+I
+3
+I
+26
+I
+13
+I
+45
+x
+72
+/Users/haruki_zaemon/Projects/hamster/lib/hamster/core_ext/enumerable.rb
+p
+0