* a.intersect?(b) #=> true

* a.intersect?(c) #=> false

*

* (items must also implement +hash+ correctly).

*/

# a.sample # => 8

# If +self+ is empty, returns +nil+.

#

# elements from +self+:

# a.sample(3) # => [8, 9, 2]

# a.sample(6) # => [9, 6, 10, 3, 1, 4]

# a.sample(a.size * 2) # => [1, 1, 3, 2, 1, 2]

# The argument +n+ must be a non-negative numeric value.

# The order of the result array is unrelated to the order of +self+.

#

# The optional +random+ argument will be used as the random number generator:

# a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# If +self+ is empty, returns +nil+.

#

# When non-negative Integer argument +n+ is given,

#

# a = [:foo, 'bar', 2]

# a.first(2) # => [:foo, "bar"]

# a = [:foo, 'bar', 2]

# a.first(50) # => [:foo, "bar", 2]

#

#

# a = [:foo, 'bar', 2]

# a.first(0) # []

# If +self+ is empty, returns +nil+.

#

# When non-negative Integer argument +n+ is given,

#

# a = [:foo, 'bar', 2]

# a.last(2) # => ["bar", 2]

# a = [:foo, 'bar', 2]

# a.last(50) # => [:foo, "bar", 2]

#

#

# a = [:foo, 'bar', 2]

# a.last(0) # []

* # Raises SyntaxError (syntax error, unexpected ':', expecting =>):

* h = {0: 'zero'}

*

* by the name of the key:

*

* x = 0

*

* You can create a +Hash+ by calling method Hash.new.

*

*

* h = Hash.new

* h # => {}

*

* You can create a +Hash+ by calling method Hash.[].

*

*

* h = Hash[]

* h # => {}

* call-seq:

* string + other_string -> new_string

*

*

* "Hello from " + self.to_s # => "Hello from main"

*

* call-seq:

* string * integer -> new_string

*

*

* "Ho! " * 3 # => "Ho! Ho! Ho! "

* "Ho! " * 0 # => ""

* call-seq:

* String.try_convert(object) -> object, new_string, or nil

*

*

* Otherwise if +object+ responds to <tt>:to_str</tt>,

* calls <tt>object.to_str</tt> and returns the result.

*

* Returns +nil+ if +object+ does not respond to <tt>:to_str</tt>.

*

*/

static VALUE

rb_str_s_try_convert(VALUE dummy, VALUE str)

*

* Returns a frozen, possibly pre-existing copy of the string.

*

* any instance variables set on it and is not a String subclass.

*

* Note that <tt>-string</tt> variant is more convenient for defining

* Returns +false+ if the two strings' encodings are not compatible:

* "\u{e4 f6 fc}".encode("ISO-8859-1") == ("\u{c4 d6 dc}") # => false

*

* two strings are compared using <code>object.==</code>.

*/

* s = '99zz99zz'

* s.succ # => "100aa00aa"

*

*

* ''.succ # => ""

*

* upto(other_string, exclusive = false) {|string| ... } -> self

* upto(other_string, exclusive = false) -> new_enumerator

*

* returned by successive calls to String#succ;

* the first value is +self+, the next is <tt>self.succ</tt>, and so on;

* the sequence terminates when value +other_string+ is reached;

* call-seq:

* to_s -> self or string

*

*/

static VALUE

/**********************************************************************

* Document-class: Symbol

*

*

*

* - A {symbol literal}[rdoc-ref:syntax/literals.rdoc@Symbol+Literals].

*

* created for a given name or string for the duration of a program's

* execution, regardless of the context or meaning of that name. Thus

* if <code>Fred</code> is a constant in one context, a method in

* will be the same object in all three contexts.

*

* module One

* local_variables

* # => [:seven]

*

*

* == What's Here

*

*

* - Inherits from {class Object}[rdoc-ref:Object@What-27s+Here].

* - Includes {module Comparable}[rdoc-ref:Comparable@What-27s+Here].

*

*

* - {Querying}[rdoc-ref:Symbol@Methods+for+Querying]

* - {Comparing}[rdoc-ref:Symbol@Methods+for+Comparing]

# typically representing text or binary data.

#

# String objects differ from Symbol objects in that Symbol objects are

# designed to be used as identifiers, instead of text or data.

#

#

# - A {string literal}[rdoc-ref:syntax/literals.rdoc@String+Literals].

# - A {heredoc literal}[rdoc-ref:syntax/literals.rdoc@Here+Document+Literals].

#

# - \Method #String.

#

# Typically, a method whose name ends with <tt>!</tt> modifies +self+

# and returns +self+;

# often a similarly named method (without the <tt>!</tt>)

#

# 'THX1138'.gsub('\d+', '00') # => "THX1138"

#

#

# If +replacement+ is a string, that string will determine

# the replacing string that is to be substituted for the matched text.

#

# Each of the examples above uses a simple string as the replacing string.

#

#

# - <tt>\n</tt> (_n_ a non-negative integer) refers to <tt>$n</tt>.

# - <tt>\k<name></tt> refers to the named capture +name+.

#

# == Whitespace in Strings

#

# consisting of any mixture of the following:

#

# - NL (null): <tt>"\x00"</tt>, <tt>"\u0000"</tt>.

# - #rstrip, #rstrip!: strip trailing whitespace.

# - #strip, #strip!: strip leading and trailing whitespace.

#

#

# A _slice_ of a string is a substring that is selected by certain criteria.

#

#

# <b><tt>string[substring]</tt></b>

#

# returns the substring from +self+ if found, otherwise +nil+:

#

# 'foo'['oo'] # => "oo"

#

# == What's Here

#

#

# - Inherits from {class Object}[rdoc-ref:Object@What-27s+Here].

# - Includes {module Comparable}[rdoc-ref:Comparable@What-27s+Here].

#

#

# - {Creating a String}[rdoc-ref:String@Methods+for+Creating+a+String]

# - {Frozen/Unfrozen Strings}[rdoc-ref:String@Methods+for+a+Frozen-2FUnfrozen+String]

# - {Converting to Non-String}[rdoc-ref:String@Methods+for+Converting+to+Non--5CString]

# - {Iterating}[rdoc-ref:String@Methods+for+Iterating]

#

#

# - ::new: Returns a new string.

# - ::try_convert: Returns a new string created from a given object.

# - #casecmp?: Returns +true+ if the string is equal to a given string after Unicode case folding;

# +false+ otherwise.

#

#

# Each of these methods modifies +self+.

#

# - #chop!: Removes trailing newline characters if found; otherwise removes the last character;

# returns +self+ if any changes, +nil+ otherwise.

#

#

# often just a modified copy of +self+.

#

# _Extension_

#

# _Duplication_

#

# otherwise, returns +self+.

#

#

#

# <em>Characters, Bytes, and Clusters</em>

#

* str.intern -> symbol

* str.to_sym -> symbol

*

* symbol if it did not previously exist. See Symbol#id2name.

*

* "Koala".intern #=> :Koala