1#@!#!123s

: / proc / self / root / opt / alt / ruby34 / share / ri / system / Hash /
Filename : cdesc-Hash.ri
back
U:RDoc::NormalClass[iI"	Hash:ET@I"Object;To:RDoc::Markup::Document:@parts[o;;[�o:RDoc::Markup::Paragraph;[I"?A +Hash+ maps each of its unique keys to a specific value.;To:RDoc::Markup::BlankLine�o;	;[I"8A +Hash+ has certain similarities to an Array, but:;To:RDoc::Markup::List:
@type:BULLET:@items[o:RDoc::Markup::ListItem:@label0;[o;	;[I")An Array index is always an Integer.;To;;0;[o;	;[I"-A +Hash+ key can be (almost) any object.;T@S:RDoc::Markup::Heading:
leveli:	textI"+Hash+ \Data Syntax;T@o;	;[I"JThe older syntax for +Hash+ data uses the "hash rocket," <tt>=></tt>:;T@o:RDoc::Markup::Verbatim;[I"+h = {:foo => 0, :bar => 1, :baz => 2}
;TI"(h # => {:foo=>0, :bar=>1, :baz=>2}
;T:@format0o;	;[I"?Alternatively, but only for a +Hash+ key that's a Symbol, ;TI",you can use a newer JSON-style syntax, ;TI"*where each bareword becomes a Symbol:;T@o;;[I""h = {foo: 0, bar: 1, baz: 2}
;TI"(h # => {:foo=>0, :bar=>1, :baz=>2}
;T;0o;	;[I"6You can also use a String in place of a bareword:;T@o;;[I"(h = {'foo': 0, 'bar': 1, 'baz': 2}
;TI"(h # => {:foo=>0, :bar=>1, :baz=>2}
;T;0o;	;[I" And you can mix the styles:;T@o;;[I"'h = {foo: 0, :bar => 1, 'baz': 2}
;TI"(h # => {:foo=>0, :bar=>1, :baz=>2}
;T;0o;	;[I"4But it's an error to try the JSON-style syntax ;TI"1for a key that's not a bareword or a String:;T@o;;[I"H# Raises SyntaxError (syntax error, unexpected ':', expecting =>):
;TI"h = {0: 'zero'}
;T;0o;	;[I"V+Hash+ value can be omitted, meaning that value will be fetched from the context ;TI"by the name of the key:;T@o;;[	I"x = 0
;TI"
y = 100
;TI"h = {x:, y:}
;TI"h # => {:x=>0, :y=>100}
;T;0S;;i;I"Common Uses;T@o;	;[I"3You can use a +Hash+ to give names to objects:;T@o;;[I"/person = {name: 'Matz', language: 'Ruby'}
;TI"4person # => {:name=>"Matz", :language=>"Ruby"}
;T;0o;	;[I"<You can use a +Hash+ to give names to method arguments:;T@o;;[	I"def some_method(hash)
;TI"  p hash
;TI"	end
;TI"Lsome_method({foo: 0, bar: 1, baz: 2}) # => {:foo=>0, :bar=>1, :baz=>2}
;T;0o;	;[I"@Note: when the last argument in a method call is a +Hash+, ;TI"%the curly braces may be omitted:;T@o;;[I"Jsome_method(foo: 0, bar: 1, baz: 2) # => {:foo=>0, :bar=>1, :baz=>2}
;T;0o;	;[I"2You can use a +Hash+ to initialize an object:;T@o;;[I"class Dev
;TI"&  attr_accessor :name, :language
;TI"  def initialize(hash)
;TI"!    self.name = hash[:name]
;TI")    self.language = hash[:language]
;TI"  end
;TI"	end
;TI"4matz = Dev.new(name: 'Matz', language: 'Ruby')
;TI"6matz # => #<Dev: @name="Matz", @language="Ruby">
;T;0S;;i;I"Creating a +Hash+;T@o;	;[I"4You can create a +Hash+ object explicitly with:;T@o;;;
;[o;;0;[o;	;[I"CA {hash literal}[rdoc-ref:syntax/literals.rdoc@Hash+Literals].;T@o;	;[I"4You can convert certain objects to Hashes with:;T@o;;;
;[o;;0;[o;	;[I"\Method #Hash.;T@o;	;[I"8You can create a +Hash+ by calling method Hash.new.;T@o;	;[I"Create an empty +Hash+:;T@o;;[I"h = Hash.new
;TI"h # => {}
;TI"h.class # => Hash
;T;0o;	;[I"7You can create a +Hash+ by calling method Hash.[].;T@o;	;[I"Create an empty +Hash+:;T@o;;[I"h = Hash[]
;TI"h # => {}
;T;0o;	;[I"*Create a +Hash+ with initial entries:;T@o;;[I"&h = Hash[foo: 0, bar: 1, baz: 2]
;TI"(h # => {:foo=>0, :bar=>1, :baz=>2}
;T;0o;	;[I"FYou can create a +Hash+ by using its literal form (curly braces).;T@o;	;[I"Create an empty +Hash+:;T@o;;[I"h = {}
;TI"h # => {}
;T;0o;	;[I"*Create a +Hash+ with initial entries:;T@o;;[I""h = {foo: 0, bar: 1, baz: 2}
;TI"(h # => {:foo=>0, :bar=>1, :baz=>2}
;T;0S;;i;I"+Hash+ Value Basics;T@o;	;[I"GThe simplest way to retrieve a +Hash+ value (instance method #[]):;T@o;;[I""h = {foo: 0, bar: 1, baz: 2}
;TI"h[:foo] # => 0
;T;0o;	;[I"PThe simplest way to create or update a +Hash+ value (instance method #[]=):;T@o;;[
I""h = {foo: 0, bar: 1, baz: 2}
;TI"h[:bat] = 3 # => 3
;TI"1h # => {:foo=>0, :bar=>1, :baz=>2, :bat=>3}
;TI"h[:foo] = 4 # => 4
;TI"1h # => {:foo=>4, :bar=>1, :baz=>2, :bat=>3}
;T;0o;	;[I"IThe simplest way to delete a +Hash+ entry (instance method #delete):;T@o;;[I""h = {foo: 0, bar: 1, baz: 2}
;TI"h.delete(:bar) # => 1
;TI"h # => {:foo=>0, :baz=>2}
;T;0S;;i;I"Entry Order;T@o;	;[I"ZA +Hash+ object presents its entries in the order of their creation. This is seen in:;T@o;;;
;[o;;0;[o;	;[I"iIterative methods such as <tt>each</tt>, <tt>each_key</tt>, <tt>each_pair</tt>, <tt>each_value</tt>.;To;;0;[o;	;[I"ZOther order-sensitive methods such as <tt>shift</tt>, <tt>keys</tt>, <tt>values</tt>.;To;;0;[o;	;[I"4The String returned by method <tt>inspect</tt>.;T@o;	;[I"AA new +Hash+ has its initial ordering per the given entries:;T@o;;[I"h = Hash[foo: 0, bar: 1]
;TI"h # => {:foo=>0, :bar=>1}
;T;0o;	;[I"&New entries are added at the end:;T@o;;[I"h[:baz] = 2
;TI"(h # => {:foo=>0, :bar=>1, :baz=>2}
;T;0o;	;[I"0Updating a value does not affect the order:;T@o;;[I"h[:baz] = 3
;TI"(h # => {:foo=>0, :bar=>1, :baz=>3}
;T;0o;	;[I":But re-creating a deleted entry can affect the order:;T@o;;[I"h.delete(:foo)
;TI"h[:foo] = 5
;TI"(h # => {:bar=>1, :baz=>3, :foo=>5}
;T;0S;;i;I"+Hash+ Keys;T@S;;i	;I"+Hash+ Key Equivalence;T@o;	;[I"VTwo objects are treated as the same \hash key when their <code>hash</code> value ;TI"Jis identical and the two objects are <code>eql?</code> to each other.;T@S;;i	;I"#Modifying an Active +Hash+ Key;T@o;	;[I"HModifying a +Hash+ key while it is in use damages the hash's index.;T@o;	;[I"*This +Hash+ has keys that are Arrays:;T@o;;[I"a0 = [ :foo, :bar ]
;TI"a1 = [ :baz, :bat ]
;TI"h = {a0 => 0, a1 => 1}
;TI"h.include?(a0) # => true
;TI"h[a0] # => 0
;TI"a0.hash # => 110002110
;T;0o;	;[I"CModifying array element <tt>a0[0]</tt> changes its hash value:;T@o;;[I"a0[0] = :bam
;TI"a0.hash # => 1069447059
;T;0o;	;[I""And damages the +Hash+ index:;T@o;;[I"h.include?(a0) # => false
;TI"h[a0] # => nil
;T;0o;	;[I"9You can repair the hash index using method +rehash+:;T@o;;[I"6h.rehash # => {[:bam, :bar]=>0, [:baz, :bat]=>1}
;TI"h.include?(a0) # => true
;TI"h[a0] # => 0
;T;0o;	;[I""A String key is always safe. ;TI"'That's because an unfrozen String ;TI"Hpassed as a key will be replaced by a duplicated and frozen String:;T@o;;[
I"s = 'foo'
;TI"s.frozen? # => false
;TI"h = {s => 0}
;TI"first_key = h.keys.first
;TI"!first_key.frozen? # => true
;T;0S;;i	;I"User-Defined +Hash+ Keys;T@o;	;[I"oTo be usable as a +Hash+ key, objects must implement the methods <code>hash</code> and <code>eql?</code>. ;TI"nNote: this requirement does not apply if the +Hash+ uses #compare_by_identity since comparison will then ;TI"Trely on the keys' object id instead of <code>hash</code> and <code>eql?</code>.;T@o;	;[I"kObject defines basic implementation for <code>hash</code> and <code>eq?</code> that makes each object ;TI"oa distinct key. Typically, user-defined classes will want to override these methods to provide meaningful ;TI"Sbehavior, or for example inherit Struct that has useful definitions for these.;T@o;	;[I"CA typical implementation of <code>hash</code> is based on the ;TI"Pobject's data while <code>eql?</code> is usually aliased to the overridden ;TI"<code>==</code> method:;T@o;;[#I"class Book
;TI"#  attr_reader :author, :title
;TI"
;TI"%  def initialize(author, title)
;TI"    @author = author
;TI"    @title = title
;TI"  end
;TI"
;TI"  def ==(other)
;TI"!    self.class === other &&
;TI"&      other.author == @author &&
;TI"!      other.title == @title
;TI"  end
;TI"
;TI"  alias eql? ==
;TI"
;TI"  def hash
;TI",    [self.class, @author, @title].hash
;TI"  end
;TI"	end
;TI"
;TI"3book1 = Book.new 'matz', 'Ruby in a Nutshell'
;TI"3book2 = Book.new 'matz', 'Ruby in a Nutshell'
;TI"
;TI"reviews = {}
;TI"
;TI")reviews[book1] = 'Great reference!'
;TI"*reviews[book2] = 'Nice and compact!'
;TI"
;TI"reviews.length #=> 1
;T;0S;;i;I"Default Values;T@o;	;[I"`The methods #[], #values_at and #dig need to return the value associated to a certain key. ;TI"\When that key is not found, that value will be determined by its default proc (if any) ;TI"+or else its default (initially `nil`).;T@o;	;[I"=You can retrieve the default value with method #default:;T@o;;[I"h = Hash.new
;TI"h.default # => nil
;T;0o;	;[I"PYou can set the default value by passing an argument to method Hash.new or ;TI"with method #default=;T@o;;[	I"h = Hash.new(-1)
;TI"h.default # => -1
;TI"h.default = 0
;TI"h.default # => 0
;T;0o;	;[I"OThis default value is returned for #[], #values_at and #dig when a key is ;TI"not found:;T@o;;[
I"counts = {foo: 42}
;TI"'counts.default # => nil (default)
;TI"counts[:foo] = 42
;TI"counts[:bar] # => nil
;TI"counts.default = 0
;TI"counts[:bar] # => 0
;TI"8counts.values_at(:foo, :bar, :baz) # => [42, 0, 0]
;TI"counts.dig(:bar) # => 0
;T;0o;	;[I"\Note that the default value is used without being duplicated. It is not advised to set ;TI"+the default value to a mutable object:;T@o;;[I"synonyms = Hash.new([])
;TI"synonyms[:hello] # => []
;TI"Gsynonyms[:hello] << :hi # => [:hi], but this mutates the default!
;TI"!synonyms.default # => [:hi]
;TI"#synonyms[:world] << :universe
;TI"2synonyms[:world] # => [:hi, :universe], oops
;TI"!synonyms.keys # => [], oops
;T;0o;	;[I"PTo use a mutable object as default, it is recommended to use a default proc;T@S;;i	;I"Default Proc;T@o;	;[I"BWhen the default proc for a +Hash+ is set (i.e., not +nil+), ;TI"Vthe default value returned by method #[] is determined by the default proc alone.;T@o;	;[I"AYou can retrieve the default proc with method #default_proc:;T@o;;[I"h = Hash.new
;TI"h.default_proc # => nil
;T;0o;	;[I"FYou can set the default proc by calling Hash.new with a block or ;TI"&calling the method #default_proc=;T@o;;[	I"=h = Hash.new { |hash, key| "Default value for #{key}" }
;TI"$h.default_proc.class # => Proc
;TI"Nh.default_proc = proc { |hash, key| "Default value for #{key.inspect}" }
;TI"$h.default_proc.class # => Proc
;T;0o;	;[	I"4When the default proc is set (i.e., not +nil+) ;TI"<and method #[] is called with with a non-existent key, ;TI"X#[] calls the default proc with both the +Hash+ object itself and the missing key, ;TI"*then returns the proc's return value:;T@o;;[I"=h = Hash.new { |hash, key| "Default value for #{key}" }
;TI"0h[:nosuch] # => "Default value for nosuch"
;T;0o;	;[I"JNote that in the example above no entry for key +:nosuch+ is created:;T@o;;[I"$h.include?(:nosuch) # => false
;T;0o;	;[I"2However, the proc itself can add a new entry:;T@o;;[
I"8synonyms = Hash.new { |hash, key| hash[key] = [] }
;TI"*synonyms.include?(:hello) # => false
;TI"(synonyms[:hello] << :hi # => [:hi]
;TI"4synonyms[:world] << :universe # => [:universe]
;TI")synonyms.keys # => [:hello, :world]
;T;0o;	;[I"TNote that setting the default proc will clear the default value and vice versa.;T@o;	;[I"SBe aware that a default proc that modifies the hash is not thread-safe in the ;TI"Usense that multiple threads can call into the default proc concurrently for the ;TI"same key.;T@S;;i;I"What's Here;T@o;	;[I",First, what's elsewhere. \Class +Hash+:;T@o;;;
;[o;;0;[o;	;[I"AInherits from {class Object}[rdoc-ref:Object@What-27s+Here].;To;;0;[o;	;[I"FIncludes {module Enumerable}[rdoc-ref:Enumerable@What-27s+Here], ;TI"1which provides dozens of additional methods.;T@o;	;[I"=Here, class +Hash+ provides methods that are useful for:;T@o;;;
;[o;;0;[o;	;[I"A{Creating a Hash}[rdoc-ref:Hash@Methods+for+Creating+a+Hash];To;;0;[o;	;[I"G{Setting Hash State}[rdoc-ref:Hash@Methods+for+Setting+Hash+State];To;;0;[o;	;[I"3{Querying}[rdoc-ref:Hash@Methods+for+Querying];To;;0;[o;	;[I"5{Comparing}[rdoc-ref:Hash@Methods+for+Comparing];To;;0;[o;	;[I"3{Fetching}[rdoc-ref:Hash@Methods+for+Fetching];To;;0;[o;	;[I"5{Assigning}[rdoc-ref:Hash@Methods+for+Assigning];To;;0;[o;	;[I"3{Deleting}[rdoc-ref:Hash@Methods+for+Deleting];To;;0;[o;	;[I"5{Iterating}[rdoc-ref:Hash@Methods+for+Iterating];To;;0;[o;	;[I"7{Converting}[rdoc-ref:Hash@Methods+for+Converting];To;;0;[o;	;[I"[{Transforming Keys and Values}[rdoc-ref:Hash@Methods+for+Transforming+Keys+and+Values];To;;0;[o;	;[I"0{And more....}[rdoc-ref:Hash@Other+Methods];T@o;	;[I"@\Class +Hash+ also includes methods from module Enumerable.;T@S;;i	;I""Methods for Creating a +Hash+;T@o;;;
;[o;;0;[o;	;[I";::[]: Returns a new hash populated with given objects.;To;;0;[o;	;[I"%::new: Returns a new empty hash.;To;;0;[o;	;[I"C::try_convert: Returns a new hash created from a given object.;T@S;;i	;I"%Methods for Setting +Hash+ State;T@o;;;
;[	o;;0;[o;	;[I"S#compare_by_identity: Sets +self+ to consider only identity in comparing keys.;To;;0;[o;	;[I"2#default=: Sets the default to a given value.;To;;0;[o;	;[I";#default_proc=: Sets the default proc to a given proc.;To;;0;[o;	;[I"Q#rehash: Rebuilds the hash table by recomputing the hash index for each key.;T@S;;i	;I"Methods for Querying;T@o;;;
;[o;;0;[o;	;[I"D#any?: Returns whether any element satisfies a given criterion.;To;;0;[o;	;[I"a#compare_by_identity?: Returns whether the hash considers only identity when comparing keys.;To;;0;[o;	;[I"O#default: Returns the default value, or the default value for a given key.;To;;0;[o;	;[I"-#default_proc: Returns the default proc.;To;;0;[o;	;[I"3#empty?: Returns whether there are no entries.;To;;0;[o;	;[I">#eql?: Returns whether a given object is equal to +self+.;To;;0;[o;	;[I"*#hash: Returns the integer hash code.;To;;0;[o;	;[I"[#has_value? (aliased as #value?): Returns whether a given object is a value in +self+.;To;;0;[o;	;[I"j#include? (aliased as #has_key?, #member?, #key?): Returns whether a given object is a key in +self+.;To;;0;[o;	;[I">#size (aliased as #length): Returns the count of entries.;T@S;;i	;I"Methods for Comparing;T@o;;;
;[
o;;0;[o;	;[I"E#<: Returns whether +self+ is a proper subset of a given object.;To;;0;[o;	;[I"?#<=: Returns whether +self+ is a subset of a given object.;To;;0;[o;	;[I"<#==: Returns whether a given object is equal to +self+.;To;;0;[o;	;[I"F#>: Returns whether +self+ is a proper superset of a given object;To;;0;[o;	;[I"A#>=: Returns whether +self+ is a superset of a given object.;T@S;;i	;I"Methods for Fetching;T@o;;;
;[o;;0;[o;	;[I"8#[]: Returns the value associated with a given key.;To;;0;[o;	;[I"L#assoc: Returns a 2-element array containing a given key and its value.;To;;0;[o;	;[I"B#dig: Returns the object in nested objects that is specified ;TI"-by a given key and additional arguments.;To;;0;[o;	;[I"/#fetch: Returns the value for a given key.;To;;0;[o;	;[I"S#fetch_values: Returns array containing the values associated with given keys.;To;;0;[o;	;[I"H#key: Returns the key for the first-found entry with a given value.;To;;0;[o;	;[I";#keys: Returns an array containing all keys in +self+.;To;;0;[o;	;[I"H#rassoc: Returns a 2-element array consisting of the key and value ;TI"3of the first-found entry having a given value.;To;;0;[o;	;[I"?#values: Returns an array containing all values in +self+/;To;;0;[o;	;[I"C#values_at: Returns an array containing values for given keys.;T@S;;i	;I"Methods for Assigning;T@o;;;
;[	o;;0;[o;	;[I"I#[]= (aliased as #store): Associates a given key with a given value.;To;;0;[o;	;[I"V#merge: Returns the hash formed by merging each given hash into a copy of +self+.;To;;0;[o;	;[I"F#update (aliased as #merge!): Merges each given hash into +self+.;To;;0;[o;	;[I"v#replace (aliased as #initialize_copy): Replaces the entire contents of +self+ with the contents of a given hash.;T@S;;i	;I"Methods for Deleting;T@o;	;[I".These methods remove entries from +self+:;T@o;;;
;[
o;;0;[o;	;[I"-#clear: Removes all entries from +self+.;To;;0;[o;	;[I"=#compact!: Removes all +nil+-valued entries from +self+.;To;;0;[o;	;[I"0#delete: Removes the entry for a given key.;To;;0;[o;	;[I";#delete_if: Removes entries selected by a given block.;To;;0;[o;	;[I"W#select! (aliased as #filter!): Keep only those entries selected by a given block.;To;;0;[o;	;[I"A#keep_if: Keep only those entries selected by a given block.;To;;0;[o;	;[I"9#reject!: Removes entries selected by a given block.;To;;0;[o;	;[I"1#shift: Removes and returns the first entry.;T@o;	;[I"EThese methods return a copy of +self+ with some entries removed:;T@o;;;
;[
o;;0;[o;	;[I"N#compact: Returns a copy of +self+ with all +nil+-valued entries removed.;To;;0;[o;	;[I"O#except: Returns a copy of +self+ with entries removed for specified keys.;To;;0;[o;	;[I"n#select (aliased as #filter): Returns a copy of +self+ with only those entries selected by a given block.;To;;0;[o;	;[I"Z#reject: Returns a copy of +self+ with entries removed as specified by a given block.;To;;0;[o;	;[I"B#slice: Returns a hash containing the entries for given keys.;T@S;;i	;I"Methods for Iterating;To;;;
;[o;;0;[o;	;[I"Q#each_pair (aliased as #each): Calls a given block with each key-value pair.;To;;0;[o;	;[I"2#each_key: Calls a given block with each key.;To;;0;[o;	;[I"6#each_value: Calls a given block with each value.;T@S;;i	;I"Methods for Converting;T@o;;;
;[
o;;0;[o;	;[I"S#inspect (aliased as #to_s): Returns a new String containing the hash entries.;To;;0;[o;	;[I"5#to_a: Returns a new array of 2-element arrays; ;TI"=each nested array contains a key-value pair from +self+.;To;;0;[o;	;[I"(#to_h: Returns +self+ if a +Hash+; ;TI"Rif a subclass of +Hash+, returns a +Hash+ containing the entries from +self+.;To;;0;[o;	;[I"#to_hash: Returns +self+.;To;;0;[o;	;[I"A#to_proc: Returns a proc that maps a given key to its value.;T@S;;i	;I"-Methods for Transforming Keys and Values;T@o;;;
;[	o;;0;[o;	;[I"B#transform_keys: Returns a copy of +self+ with modified keys.;To;;0;[o;	;[I".#transform_keys!: Modifies keys in +self+;To;;0;[o;	;[I"F#transform_values: Returns a copy of +self+ with modified values.;To;;0;[o;	;[I"3#transform_values!: Modifies values in +self+.;T@S;;i	;I"Other Methods;To;;;
;[o;;0;[o;	;[I"M#flatten: Returns an array that is a 1-dimensional flattening of +self+.;To;;0;[o;	;[I"C#invert: Returns a hash with the each key-value pair inverted.;T:
@fileI"hash.c;T:0@omit_headings_from_table_of_contents_below0o;;[�;I"hash.rb;T;0;0;0[�[�[[I"Enumerable;To;;[�;@�;0I"hash.c;T[[I"
class;T[[:public[
[I"[];T@�[I"new;TI"hash.rb;T[I"ruby2_keywords_hash;T@�[I"ruby2_keywords_hash?;T@�[I"try_convert;T@�[:protected[�[:private[�[I"
instance;T[[;[M[I"<;T@�[I"<=;T@�[I"==;T@�[I">;T@�[I">=;T@�[I"[];T@�[I"[]=;T@�[I"	any?;T@�[I"
assoc;T@�[I"
clear;T@�[I"compact;T@�[I"
compact!;T@�[I"compare_by_identity;T@�[I"compare_by_identity?;T@�[I"default;T@�[I"
default=;T@�[I"default_proc;T@�[I"default_proc=;T@�[I"delete;T@�[I"delete_if;T@�[I"dig;T@�[I"	each;T@�[I"
each_key;T@�[I"each_pair;T@�[I"each_value;T@�[I"empty?;T@�[I"	eql?;T@�[I"except;T@�[I"
fetch;T@�[I"fetch_values;T@�[I"filter;T@�[I"filter!;T@�[I"flatten;T@�[I"
has_key?;T@�[I"has_value?;T@�[I"	hash;T@�[I"
include?;T@�[I"initialize_copy;T@�[I"inspect;T@�[I"invert;T@�[I"keep_if;T@�[I"key;T@�[I"	key?;T@�[I"	keys;T@�[I"length;T@�[I"member?;T@�[I"
merge;T@�[I"merge!;T@�[I"rassoc;T@�[I"rehash;T@�[I"reject;T@�[I"reject!;T@�[I"replace;T@�[I"select;T@�[I"select!;T@�[I"
shift;T@�[I"	size;T@�[I"
slice;T@�[I"
store;T@�[I"	to_a;T@�[I"	to_h;T@�[I"to_hash;T@�[I"to_proc;T@�[I"	to_s;T@�[I"transform_keys;T@�[I"transform_keys!;T@�[I"transform_values;T@�[I"transform_values!;T@�[I"update;T@�[I"value?;T@�[I"values;T@�[I"values_at;T@�[;[�[;[�[�[U:RDoc::Context::Section[i�0o;;[�;0;0[@�@�I"lib/pp.rb;T@dcRDoc::TopLevel