gorillib hashlike variations

gorillib/hashlike -- Variations

Class must implement

    has_key?
    each_pair
    keys
    []=
    []
    unset!

• HashlikeAccessors

    instance_variable_set 
    [], []=, merge, merge!, reverse_merge, reverse_merge 
  

Mash:

DeepHash:

deep_get, deep_set, deep_unset

• gorillib/hashlike
• gorillib/hashlike/slice
• gorillib/hashlike/deep_dup
• gorillib/hashlike/
• gorillib/hashlike/hashlike_via_accessors
• gorillib/struct/acts_as_hash
• gorillib/struct/iterates_as_hash

acts_as_hash

• []= associates key with value

• [] retrieves value associated with given key

• delete removes that key and its association

• keys enumeration of all keys having associations.

• check for compatibility/semantics of Enumerable

• has_key? true if an association exists for the given key.

hashlike

Want chokepoints:

keys

• each, each_pair
  • each_value
  • reject!
    • delete_if
    • reject
  • select!
    • keep_if
• each_key
• key
• has_key?
  • values_at
• length, size
• empty?

• each keys.each{|k| yield [k, self[k]] } ; self

• has_key? keys.include?(k)

• length keys.length

• size alias for length

• empty? keys.empty?

• each_pair alias for each

• each_key keys.each{|k| yield k }

• each_value each{|k,v| yield v }

• key keys.find{|k| self[k] == val }

• values_at in_keys.each{|k| self[k] if has_key?(k) }

• values [].tap{|arr| each{|k,v| arr << v } }

• to_hash {}.tap{|hsh| each{|k,v| hsh[k] = v } }

• has_value? keys.any?{|k| self[k] == val }

• value? alias for has_value?

• include? alias for has_key?

• key? alias for has_key?

• member? alias for has_key?

• update other_hash.each{|k,v| self[k] = (block_given? && has_key?(k) ? yield(k,v,self[k]) : v) }

• merge! update

• merge dup.merge!

• reject! chgd = false ; each{|k,v| if yield(k,v) then delete(k); chgd = true ; end } chgd ? self : nil

• select! chgd = false ; each{|k,v| if !yield(k,v) then delete(k); chgd = true ; end } chgd ? self : nil

• delete_if: reject! ; return self

• keep_if: select! ; return self

• reject: self.dup.delete_if

• fetch [] if has_key? else default else yield else raise KeyError

• clear each_key{|k| delete(k) }

• invert to_hash.invert

  #all?, #any?, #chunk, #collect, #collect_concat, #count, #cycle, #detect, #drop, #drop_while, #each_cons, #each_entry, #each_slice, #each_with_index, #each_with_object, #entries, #find, #find_all, #find_index, #first, #flat_map, #grep, #group_by, #inject, #map, #max, #max_by, #min, #min_by, #minmax, #minmax_by, #none?, #one?, #partition, #reduce, #reverse_each, #slice_before, #sort, #sort_by, #take, #take_while, #zip

As opposed to hash, does not define

default, default=, default_proc, default_proc=, replace, rehash, compare_by_identity compare_by_identity?, shift, flatten,

Configliere::DeepHash -- a magic hash

• only allows handles as keys (only things that can be turned into symbols are interesting)
• indifferent access
• deep access, via the dotted hash

• FancyHash

• gorillib/hash/compact compact, compact!, compact_blank, compact_blank!

• gorrilib/hash/deep_compact deep_compact, deep_compact!

• gorrilib/hash/deep_merge deep_merge, deep_merge!

• gorillib/hash/keys stringify_keys, stringify_keys!, symbolize_keys, symbolize_keys!, assert_valid_keys

• gorillib/hash/reverse_merge reverse_merge, reverse_merge!

• gorillib/hash/tree_merge tree_merge, tree_merge!

• gorillib/hash/slice slice, slice!, extract!

• gorillib/hash/zip Hash.zip

• Receiver

---

?> [ :store, :delete, :keys, :each, :each_key, :each_value, :has_key?, :include?, :key?, :member?, :has_value?, :value?, :fetch, :length, :empty?, :to_hash, :values, :values_at, :merge, :update, :key, :invert, :reject!, :select!, :delete_if, :keep_if, :reject, :clear, :assoc, :rassoc].each{|m| puts ri 'Hash##{m}' }