Skip to content

Latest commit

 

History

History
419 lines (215 loc) · 8.46 KB

File metadata and controls

419 lines (215 loc) · 8.46 KB
  • Track size on Tries for performance (fredericksgary)

  • Hash#values should not return a set as there is no guarantee of uniqueness (and worse it means you potentially lose duplicate values). (fredericksgary)

  • Add Hash#slice, Hash#except, Hash#fetch (misfo)

  • Implemented a public Hash#new for subclassing (misfo)

  • Some initial benchmarks (haedius)

  • Documentation corrections (harukizaemon, szajbus, rwfowler)

  • Added List#merge/merge_by to merge sorted lists into a single stream.

  • Added Enumerator#to_list produces a lazy list.

  • Alias List/Set#group_by as #group.

  • Added initial implementation of Vector for efficient indexed access.

  • Fix car/cdr so they work on Ruby 1.8.7 (tianyicui)

  • Fix specs when running under 1.8.7 (tianyicui, kef)

  • Fix bundler/rvm support (kef)

  • Update to RSpec 2.

  • Implement Hash#values.

  • Hash now accepts a block for supplying default values.

  • Initial Queue implementation complete.

  • Implement Stack#peek.

  • Add Stack#enqueue, #dequeue to reflect the fact that a Stack is also a LIFO Queue.

  • Fix incompatibilities with Ruby 1.8.7 syntax.

  • Hash#put now supports returning a value from a block instead of passing an explicit value. Almost like a substitute for the non-functional []=

  • Reduce garbage collection by keeping a singleton instance of an empty hash.

  • Added some VERY experimental Read-Copy-Update collections (no tests).

  • Slightly improve performance and greatly improve the readability of #eql?/#== methods.

  • Added some VERY experimental memoization for immutable objects.

  • Added Set#merge as an alias for Set#union.

  • Implemented Hash#merge (aliased as #+).

  • Fixed: hash code generation had VERY poor distribution.

  • Fixed: Immutable not required in hamster.rb

  • Add Hamster::Immutable as general purpose module to facililate immutability.

  • List, Stack, Set, and Hash now all implement Hamster::Immutable.

  • Implement Hash#hash.

  • Implement Set#hash.

  • Implement List#hash.

  • Implement Set#flatten.

  • Fixed bug: List#join accidentally modifying head if it was a string.

  • Implement Set#one?

  • Implement Set#minimum (aliased as #min).

  • Implement Set#maximum (aliased as #max).

  • Implement Set#reduce with an optional memo.

  • Fix List#reduce should return nil when given no block and no starting value.

  • Fix a bunch of spec failures under 1.8.7.

  • Remove some redundant object construction.

  • Fix #to_list not available in all Enumerables.

  • Implement Set#exclusion (aliased as #^) as equivalent to ((a | b) - (a & b)).

  • Implement Set#subset?

  • Implement Set#superset?

  • Implement Set#difference (aliased as #diff, #subtract, and #-).

  • Implement Set#intersection (aliased as #intersect and #&).

  • Implement Set#union (aliased as #| and #+).

  • Implement Set#union (aliased as #| and #+).

  • Remove Hash#[]= as its useless.

  • Fixed bug with Hamster.interval (and Hamster.range) not handling Strings correctly.

  • Implement Array#to_list.

  • Simplify (and improve performance of) conversions from arrays to lists.

  • Speed up Set and List sorting.

  • Implement Hash#find (aliased as #detect).

  • Implement List#elem_indices, List#find_indices (aliased as #indices as appropriate).

  • Implement List#index as per MRI and alias as #elem_index, and #find_index as appropriate.

  • Remove some redundant construction of streams.

  • Implement Set#clear.

  • Implement List#slice (also aliased as #[from, length]).

  • Implement List#at (aliased as #[index]).

  • Fix List#cadr and friends under JRuby.

  • Remove redundant locking (speed up).

  • Make reverse “lazy” (ish).

  • Fixed: StackOverflow calling List#head and List#tail on very large lazy lists.

  • Alias #reduce as #foldr.

  • Implement Set#group_by.

  • Implement List#group_by.

  • Implement Hash#inspect.

  • Tuples can now be implicitly converted to args and variables via #to_ary, meaning you can do:

    integers = Hamster.iterate(1, &:succ)
    odds, evens = integers.partition(&:odd?)
    
  • Implement List#flatten.

  • Implement List#each_slice (aliased as #each_chunk).

  • Return a tuple rather than a list for #split_at, #partition, #break, and #span.

  • Implement List#chunk.

  • Implement Set#compact.

  • Implement List#compact.

  • Fix bug: List#empty? would cause a stack overflow on very large streams.

  • List methods that return lists are now all lazy. Not sure what, if any, negative impact this will have but the positives have so far been well worth it.

  • Ensure List#eql? (and #==) doesn’t accidentally consider an empty list to be equal to an empty array!

  • Ensure List responds_to? cadr and friends.

  • Stream now releases the block for garbage collection once called.

  • Implement List#combinations.

  • Implement List#inits.

  • Implement List#tails.

  • Implement Hash#uniq.

  • Alias #uniq as #remove_duplicates.

  • Alias #all? as #forall?

  • Implement Set#product.

  • Implement Set#sum.

  • Implement List#product.

  • Implement List#sum.

  • Implement List#last.

  • Implement List#init.

  • Alias #reject as #remove.

  • Alias #each as #foreach.

  • Rename Hash#remove as Hash#delete.

  • Rename Set#remove as Set#delete.

  • Implement List#union (aliased as #|).

  • Implement List#uniq (aliased as #nub).

  • Implement List#intersperse.

  • Alias #include? as #elem?

  • Implement Stack#to_list.

  • Implement Stack#to_a.

  • Implement Set#join.

  • Implement Set#count.

  • Implement List#count.

  • Alias #include? as #contains?

  • #each now returns nil if you specify a block.

  • Implement Set#find (aliased as #detect).

  • Implement List#sort. (Very, VERY inefficient implementation!)

  • Implement List#sort_by. (Very, VERY inefficient implementation!)

  • Implement Set#to_set.

  • Implement Set#inspect.

  • Implement Set#first (aliased as #head).

  • Implement Set#sort. (Very, VERY inefficient implementation!)

  • Implement Set#sort_by. (Very, VERY inefficient implementation!)

  • Implement List#join.

  • Implement Stack#clear.

  • Implement List#clear and Stack#clear.

  • Implement List#break.

  • Implement List#span.

  • Bump minimum Ruby version to 1.8.7. I mean really, c’mon!

  • Added gem development dependency on RSpec.

  • Alias #empty? as #null?

  • Implement List#split_at.

  • Implement List.iterate.

  • Implement List#cycle.

  • Implement List.replicate.

  • Implement List.repeat.

  • Simplify List#take.

  • Simplify any?, all?, and none?

  • Re-write List#one? to be less complex.

  • Add Set#to_list.

  • Implement List#zip.

  • Implement Set#grep.

  • Implement Set#uniq (aliased as #nub).

  • Implement List#grep.

  • 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).

  • Implemented IO#to_list.

  • Implemented Enumerable#to_list.

  • List#reduce supports optional initial value.

  • Implemented List#to_ary for implicit conversion to arrays and call parameters.

  • Implemented Set#to_a.

  • Alias #filter as #find_all.

  • Alias #reject as #delete_if.

  • Alias #reduce as #fold.

  • Stack now fully functional

  • List methods are now lazy where feasible

  • Now works under Ruby >= 1.8.6

  • Add convenience constructors: List[], Set[], and Hash[]

  • Implemented #eql?/== for Hash and Set.

  • First cut at finishing implementation of Hash.

  • Add some examples

  • Simplify and share Trie between Hash and Set

  • All known issues fixed.

  • Fixed all but one outstanding issue with #remove

  • Added #remove

  • Initial version