Index of Files, Classes & Methods in Ruby 2.1.2 (Ruby 2.1.2)

Support for the Ruby 2.1 series ended on March 31 2017. See here for details.

Ruby 2.1.2

New to Ruby? You may find these links helpful: syntax, control expressions, assignment, methods, modules + classes, and operator precedence.

This is the API documentation for Ruby 2.1.2.

Files

.lib/racc/rdoc/grammar.en.rdoc

.test/rdoc/test.ja.large.rdoc

.test/rdoc/test.ja.rdoc

doc/contributing.rdoc

doc/contributors.rdoc

doc/dtrace_probes.rdoc

doc/globals.rdoc

doc/maintainers.rdoc

doc/marshal.rdoc

doc/regexp.rdoc

doc/security.rdoc

doc/standard_library.rdoc

doc/syntax.rdoc

doc/syntax/assignment.rdoc

doc/syntax/calling_methods.rdoc

doc/syntax/control_expressions.rdoc

doc/syntax/exceptions.rdoc

doc/syntax/literals.rdoc

doc/syntax/methods.rdoc

doc/syntax/miscellaneous.rdoc

doc/syntax/modules_and_classes.rdoc

doc/syntax/precedence.rdoc

doc/syntax/refinements.rdoc

sample/drb/README.ja.rdoc

sample/drb/README.rdoc

Classes

CComplex::compatible

CConditionVariable

CEncoding::CompatibilityError

CEncoding::Converter

CEncoding::ConverterNotFoundError

CEncoding::InvalidByteSequenceError

CEncoding::UndefinedConversionError

CEnumerator::Generator

CEnumerator::Lazy

CEnumerator::Yielder

MFile::Constants

CFloatDomainError

CIO::EAGAINWaitReadable

CIO::EAGAINWaitWritable

CIO::EINPROGRESSWaitReadable

CIO::EINPROGRESSWaitWritable

CIO::EWOULDBLOCKWaitReadable

CIO::EWOULDBLOCKWaitWritable

MIO::WaitReadable

MIO::WaitWritable

CLocalJumpError

CMath::DomainError

CNotImplementedError

CObjectSpace::WeakMap

CProcess::Status

CRational::compatible

CRubyVM::InstructionSequence

CSignalException

CSystemCallError

CSystemStackError

CThread::Backtrace

CThread::Backtrace::Location

CZeroDivisionError

Methods

::=== (SystemCallError)

::DEBUG (Thread)

::DEBUG= (Thread)

::_id2ref (ObjectSpace)

::abort (Process)

::abort_on_exception (Thread)

::abort_on_exception= (Thread)

::absolute_path (File)

::aliases (Encoding)

::all_symbols (Symbol)

::argv0 (Process)

::asciicompat_encoding (Encoding::Converter)

::basename (File)

::binwrite (IO)

::blockdev? (File)

::change_privilege (Process::GID)

::change_privilege (Process::UID)

::chardev? (File)

::clear (GC::Profiler)

::clock_getres (Process)

::clock_gettime (Process)

::compatible? (Encoding)

::compile (Regexp)

::compile (RubyVM::InstructionSequence)

::compile_file (RubyVM::InstructionSequence)

::compile_option (RubyVM::InstructionSequence)

::compile_option= (RubyVM::InstructionSequence)

::constants (Module)

::copy_stream (IO)

::count_objects (ObjectSpace)

::current (Fiber)

::current (Thread)

::daemon (Process)

::default_external (Encoding)

::default_external= (Encoding)

::default_internal (Encoding)

::default_internal= (Encoding)

::define_finalizer (ObjectSpace)

::delete (File)

::delete_if (ENV)

::detach (Process)

::directory? (File)

::dirname (File)

::disable (GC::Profiler)

::disasm (RubyVM::InstructionSequence)

::disassemble (RubyVM::InstructionSequence)

::dump (Marshal)

::each_key (ENV)

::each_object (ObjectSpace)

::each_pair (ENV)

::each_value (ENV)

::egid (Process)

::egid= (Process)

::eid (Process::GID)

::eid (Process::UID)

::enable (GC::Profiler)

::enabled? (GC::Profiler)

::entries (Dir)

::escape (Regexp)

::euid (Process)

::euid= (Process)

::exception (Exception)

::exclusive (Thread)

::exec (Process)

::executable? (File)

::executable_real? (File)

::exist? (File)

::exists? (Dir)

::exists? (File)

::exit (Process)

::exit (Thread)

::exit! (Process)

::expand_path (File)

::extname (File)

::find (Encoding)

::fnmatch (File)

::fnmatch? (File)

::foreach (Dir)

::fork (Process)

::fork (Thread)

::from_name (Process::GID)

::from_name (Process::UID)

::garbage_collect (ObjectSpace)

::getegid (Process::Sys)

::geteuid (Process::Sys)

::getgid (Process::Sys)

::getpgid (Process)

::getpgrp (Process)

::getpriority (Process)

::getrlimit (Process)

::getsid (Process)

::getuid (Process::Sys)

::gid (Process)

::gid= (Process)

::grant_privilege (Process::GID)

::grant_privilege (Process::UID)

::groups (Process)

::groups= (Process)

::grpowned? (File)

::handle_interrupt (Thread)

::has_key? (ENV)

::has_value? (ENV)

::identical? (File)

::include? (ENV)

::initgroups (Process)

::inspect (ENV)

::issetugid (Process::Sys)

::keep_if (ENV)

::kill (Process)

::kill (Thread)

::last_match (Regexp)

::latest_gc_info (GC)

::lchmod (File)

::lchown (File)

::lgamma (Math)

::list (Encoding)

::list (Signal)

::list (Thread)

::load (Marshal)

::main (Thread)

::malloc_allocated_size (GC)

::malloc_allocations (GC)

::maxgroups (Process)

::maxgroups= (Process)

::member? (ENV)

::mktime (Time)

::name_list (Encoding)

::nesting (Module)

::new (BasicObject)

::new (ConditionVariable)

::new (Encoding::Converter)

::new (Enumerator)

::new (Enumerator::Lazy)

::new (Exception)

::new (File::Stat)

::new (NameError)

::new (NoMethodError)

::new (RubyVM::InstructionSequence)

::new (SignalException)

::new (SizedQueue)

::new (SystemCallError)

::new (SystemExit)

::new (TracePoint)

::new_seed (Random)

::of (RubyVM::InstructionSequence)

::owned? (File)

::pass (Thread)

::pending_interrupt? (Thread)

::pid (Process)

::polar (Complex)

::ppid (Process)

::quote (Regexp)

::rand (Random)

::raw_data (GC::Profiler)

::re_exchange (Process::GID)

::re_exchange (Process::UID)

::re_exchangeable? (Process::GID)

::re_exchangeable? (Process::UID)

::readable? (File)

::readable_real? (File)

::readlines (IO)

::readlink (File)

::realdirpath (File)

::realpath (File)

::rect (Complex)

::rectangular (Complex)

::reject! (ENV)

::rename (File)

::replace (ENV)

::report (GC::Profiler)

::restore (Marshal)

::result (GC::Profiler)

::rid (Process::GID)

::rid (Process::UID)

::search_convpath (Encoding::Converter)

::select! (ENV)

::setegid (Process::Sys)

::seteuid (Process::Sys)

::setgid (Process::Sys)

::setgid? (File)

::setpgid (Process)

::setpgrp (Process)

::setpriority (Process)

::setproctitle (Process)

::setregid (Process::Sys)

::setresgid (Process::Sys)

::setresuid (Process::Sys)

::setreuid (Process::Sys)

::setrgid (Process::Sys)

::setrlimit (Process)

::setruid (Process::Sys)

::setsid (Process)

::setuid (Process::Sys)

::setuid? (File)

::sid_available? (Process::GID)

::sid_available? (Process::UID)

::signame (Signal)

::socket? (File)

::spawn (Process)

::srand (Random)

::start (Thread)

::stat (RubyVM)

::sticky? (File)

::stop (Thread)

::switch (Process::GID)

::switch (Process::UID)

::symlink (File)

::symlink? (File)

::times (Process)

::to_hash (ENV)

::total_time (GC::Profiler)

::trace (TracePoint)

::trap (Signal)

::truncate (File)

::try_convert (Array)

::try_convert (Hash)

::try_convert (IO)

::try_convert (Regexp)

::try_convert (String)

::uid (Process)

::uid= (Process)

::undefine_finalizer (ObjectSpace)

::union (Regexp)

::unlink (File)

::values_at (ENV)

::verify_internal_consistency (GC)

::wait (Process)

::wait2 (Process)

::waitall (Process)

::waitpid (Process)

::waitpid2 (Process)

::world_readable? (File)

::world_writable? (File)

::writable? (File)

::writable_real? (File)

::yield (Fiber)

#! (BasicObject)

#!= (BasicObject)

#& (FalseClass)

#& (Process::Status)

#< (Comparable)

#<< (SizedQueue)

#<= (Comparable)

#<=> (File::Stat)

#<=> (Rational)

#== (BasicObject)

#== (Comparable)

#== (Encoding::Converter)

#== (Exception)

#== (MatchData)

#== (Process::Status)

#== (UnboundMethod)

#> (Comparable)

#>= (Comparable)

#>> (Process::Status)

#Array (Kernel)

#Complex (Kernel)

#Float (Kernel)

#Integer (Kernel)

#Rational (Kernel)

#String (Kernel)

#[] (Continuation)

#[] (MatchData)

#[] (ObjectSpace::WeakMap)

#[]= (ObjectSpace::WeakMap)

#^ (FalseClass)

#__callee__ (Kernel)

#__dir__ (Kernel)

#__id__ (BasicObject)

#__method__ (Kernel)

#__send__ (BasicObject)

#abort (Kernel)

#abort_on_exception (Thread)

#abort_on_exception= (Thread)

#abs2 (Complex)

#abs2 (Numeric)

#absolute_path (RubyVM::InstructionSequence)

#absolute_path (Thread::Backtrace::Location)

#add (ThreadGroup)

#add_trace_func (Thread)

#alias_method (Module)

#alive? (Fiber)

#alive? (Thread)

#all? (Enumerable)

#allocate (Class)

#ancestors (Module)

#angle (Complex)

#angle (Numeric)

#any? (Enumerable)

#append_features (Module)

#args (NoMethodError)

#arity (Method)

#arity (UnboundMethod)

#ascii_compatible? (Encoding)

#ascii_only? (String)

#asctime (Time)

#at_exit (Kernel)

#atime (File::Stat)

#attr_accessor (Module)

#attr_reader (Module)

#attr_writer (Module)

#autoclose= (IO)

#autoclose? (IO)

#autoload (Kernel)

#autoload (Module)

#autoload? (Kernel)

#autoload? (Module)

#backtrace (Exception)

#backtrace (Thread)

#backtrace_locations (Exception)

#backtrace_locations (Thread)

#base_label (RubyVM::InstructionSequence)

#base_label (Thread::Backtrace::Location)

#begin (MatchData)

#between? (Comparable)

#bind (UnboundMethod)

#binding (Kernel)

#binding (Proc)

#binding (TracePoint)

#binmode (ARGF)

#binmode? (ARGF)

#bit_length (Bignum)

#bit_length (Fixnum)

#blksize (File::Stat)

#block_given? (Kernel)

#blockdev? (File::Stat)

#blockdev? (FileTest)

#blocks (File::Stat)

#broadcast (ConditionVariable)

#bsearch (Array)

#bsearch (Range)

#bytes (Random)

#bytes (String)

#bytesize (String)

#byteslice (String)

#call (Continuation)

#callcc (Kernel)

#caller (Kernel)

#caller_locations (Kernel)

#capitalize (String)

#capitalize (Symbol)

#capitalize! (String)

#captures (MatchData)

#casecmp (String)

#casecmp (Symbol)

#casefold? (Regexp)

#catch (Kernel)

#cause (Exception)

#ceil (Integer)

#ceil (Numeric)

#ceil (Rational)

#center (String)

#chardev? (File::Stat)

#chardev? (FileTest)

#chars (String)

#chomp (Kernel)

#chomp (String)

#chomp! (String)

#chop! (String)

#chunk (Enumerable)

#chunk (Enumerator::Lazy)

#class (Object)

#class_eval (Module)

#class_exec (Module)

#class_variable_defined? (Module)

#class_variable_get (Module)

#class_variable_set (Module)

#class_variables (Module)

#clear (SizedQueue)

#clear (String)

#clone (Method)

#clone (Object)

#clone (UnboundMethod)

#close_on_exec= (IO)

#close_on_exec? (IO)

#close_read (IO)

#close_write (IO)

#closed? (ARGF)

#codepoints (ARGF)

#codepoints (IO)

#codepoints (String)

#coerce (Bignum)

#coerce (Float)

#coerce (Numeric)

#collect (Array)

#collect (Enumerable)

#collect (Enumerator::Lazy)

#collect! (Array)

#collect_concat (Enumerable)

#collect_concat (Enumerator::Lazy)

#combination (Array)

#compact (Array)

#compact! (Array)

#compare_by_identity (Hash)

#compare_by_identity? (Hash)

#concat (Array)

#concat (String)

#conj (Complex)

#conj (Numeric)

#conjugate (Complex)

#conjugate (Numeric)

#const_defined? (Module)

#const_get (Module)

#const_missing (Module)

#const_set (Module)

#constants (Module)

#convert (Encoding::Converter)

#convpath (Encoding::Converter)

#coredump? (Process::Status)

#count (Enumerable)

#count (String)

#cover? (Range)

#crypt (String)

#ctime (File::Stat)

#cycle (Enumerable)

#default (Hash)

#default= (Hash)

#default_proc (Hash)

#default_proc= (Hash)

#define_method (Module)

#define_singleton_method (Object)

#defined_class (TracePoint)

#delete (Array)

#delete (String)

#delete! (String)

#delete_at (Array)

#delete_if (Array)

#delete_if (Hash)

#denominator (Complex)

#denominator (Float)

#denominator (Integer)

#denominator (Numeric)

#denominator (Rational)

#deq (SizedQueue)

#destination_encoding (Encoding::Converter)

#destination_encoding (Encoding::InvalidByteSequenceError)

#destination_encoding (Encoding::UndefinedConversionError)

#destination_encoding_name (Encoding::InvalidByteSequenceError)

#destination_encoding_name (Encoding::UndefinedConversionError)

#detect (Enumerable)

#dev (File::Stat)

#dev_major (File::Stat)

#dev_minor (File::Stat)

#directory? (File::Stat)

#directory? (FileTest)

#disable (TracePoint)

#disasm (RubyVM::InstructionSequence)

#disassemble (RubyVM::InstructionSequence)

#display (Object)

#divmod (Bignum)

#divmod (Fixnum)

#divmod (Float)

#divmod (Numeric)

#downcase (String)

#downcase (Symbol)

#downcase! (String)

#downto (Integer)

#drop (Enumerable)

#drop (Enumerator::Lazy)

#drop_while (Array)

#drop_while (Enumerable)

#drop_while (Enumerator::Lazy)

#dummy? (Encoding)

#each (Enumerator)

#each (ObjectSpace::WeakMap)

#each_byte (ARGF)

#each_byte (IO)

#each_byte (String)

#each_char (ARGF)

#each_char (IO)

#each_char (String)

#each_codepoint (ARGF)

#each_codepoint (IO)

#each_codepoint (String)

#each_cons (Enumerable)

#each_entry (Enumerable)

#each_index (Array)

#each_key (Hash)

#each_key (ObjectSpace::WeakMap)

#each_line (ARGF)

#each_line (IO)

#each_line (String)

#each_pair (Hash)

#each_pair (ObjectSpace::WeakMap)

#each_pair (Struct)

#each_slice (Enumerable)

#each_value (Hash)

#each_value (ObjectSpace::WeakMap)

#each_with_index (Enumerable)

#each_with_index (Enumerator)

#each_with_object (Enumerable)

#each_with_object (Enumerator)

#empty? (Array)

#empty? (Queue)

#empty? (String)

#empty? (Symbol)

#enable (TracePoint)

#enabled? (TracePoint)

#enclose (ThreadGroup)

#enclosed? (ThreadGroup)

#encode (String)

#encode! (String)

#encoding (Regexp)

#encoding (String)

#encoding (Symbol)

#end (MatchData)

#end_with? (String)

#enq (SizedQueue)

#entries (Enumerable)

#enum_for (Enumerator::Lazy)

#enum_for (Object)

#eql? (MatchData)

#eql? (Numeric)

#eql? (UnboundMethod)

#equal? (BasicObject)

#errno (SystemCallError)

#error_bytes (Encoding::InvalidByteSequenceError)

#error_char (Encoding::UndefinedConversionError)

#eval (Binding)

#eval (RubyVM::InstructionSequence)

#even? (Bignum)

#even? (Fixnum)

#even? (Integer)

#event (TracePoint)

#exception (Exception)

#exclude_end? (Range)

#executable? (File::Stat)

#executable? (FileTest)

#executable_real? (File::Stat)

#executable_real? (FileTest)

#exist? (FileTest)

#exists? (FileTest)

#exit! (Kernel)

#exit_value (LocalJumpError)

#exited? (Process::Status)

#exitstatus (Process::Status)

#extend (Object)

#extend_object (Module)

#extended (Module)

#external_encoding (ARGF)

#external_encoding (IO)

#fdatasync (IO)

#fdiv (Complex)

#fdiv (Numeric)

#fdiv (Rational)

#feed (Enumerator)

#file? (File::Stat)

#file? (FileTest)

#filename (ARGF)

#finalize (ObjectSpace::WeakMap)

#find (Enumerable)

#find_all (Enumerable)

#find_all (Enumerator::Lazy)

#find_index (Array)

#find_index (Enumerable)

#finish (Encoding::Converter)

#finite? (Float)

#first (Enumerable)

#first_lineno (RubyVM::InstructionSequence)

#fixed_encoding? (Regexp)

#flat_map (Enumerable)

#flat_map (Enumerator::Lazy)

#flatten (Array)

#flatten (Hash)

#flatten! (Array)

#floor (Integer)

#floor (Numeric)

#floor (Rational)

#force_encoding (String)

#format (Kernel)

#freeze (Module)

#freeze (Object)

#friday? (Time)

#frozen? (Array)

#frozen? (Object)

#ftype (File::Stat)

#garbage_collect (GC)

#gcdlcm (Integer)

#getbyte (ARGF)

#getbyte (String)

#getlocal (Time)

#gid (File::Stat)

#global_variables (Kernel)

#gmt_offset (Time)

#grep (Enumerable)

#grep (Enumerator::Lazy)

#group (Thread)

#group_by (Enumerable)

#grpowned? (File::Stat)

#grpowned? (FileTest)

#gsub! (String)

#has_key? (Hash)

#has_value? (Hash)

#hash (MatchData)

#hash (UnboundMethod)

#id2name (Symbol)

#identical? (FileTest)

#imag (Complex)

#imag (Numeric)

#imaginary (Complex)

#imaginary (Numeric)

#include (Module)

#include? (Array)

#include? (Enumerable)

#include? (Hash)

#include? (Module)

#include? (ObjectSpace::WeakMap)

#include? (Range)

#include? (String)

#included (Module)

#included_modules (Module)

#incomplete_input? (Encoding::InvalidByteSequenceError)

#index (String)

#infinite? (Float)

#inherited (Class)

#initialize_copy (Array)

#initialize_copy (Numeric)

#initialize_copy (String)

#inject (Enumerable)

#ino (File::Stat)

#inplace_mode (ARGF)

#inplace_mode= (ARGF)

#insert (Array)

#insert (String)

#insert_output (Encoding::Converter)

#inspect (ARGF)

#inspect (Array)

#inspect (Bignum)

#inspect (Complex)

#inspect (Encoding)

#inspect (Encoding::Converter)

#inspect (Enumerator)

#inspect (Exception)

#inspect (FalseClass)

#inspect (File::Stat)

#inspect (Fixnum)

#inspect (Float)

#inspect (Hash)

#inspect (MatchData)

#inspect (Method)

#inspect (Module)

#inspect (NilClass)

#inspect (Object)

#inspect (ObjectSpace::WeakMap)

#inspect (Proc)

#inspect (Process::Status)

#inspect (Range)

#inspect (Rational)

#inspect (Regexp)

#inspect (RubyVM::InstructionSequence)

#inspect (String)

#inspect (Struct)

#inspect (Symbol)

#inspect (Thread)

#inspect (Thread::Backtrace::Location)

#inspect (Time)

#inspect (TracePoint)

#inspect (TrueClass)

#inspect (UnboundMethod)

#instance_eval (BasicObject)

#instance_exec (BasicObject)

#instance_method (Module)

#instance_methods (Module)

#instance_of? (Object)

#instance_variable_defined? (Object)

#instance_variable_get (Object)

#instance_variable_set (Object)

#instance_variables (Object)

#integer? (Integer)

#integer? (Numeric)

#intern (String)

#intern (Symbol)

#internal_encoding (ARGF)

#internal_encoding (IO)

#is_a? (Object)

#iterator? (Kernel)

#keep_if (Array)

#keep_if (Hash)

#key? (ObjectSpace::WeakMap)

#keys (ObjectSpace::WeakMap)

#kind_of? (Object)

#label (RubyVM::InstructionSequence)

#label (Thread::Backtrace::Location)

#lambda (Kernel)

#lambda? (Proc)

#last_error (Encoding::Converter)

#lazy (Enumerable)

#lazy (Enumerator::Lazy)

#length (Array)

#length (MatchData)

#length (ObjectSpace::WeakMap)

#length (Queue)

#length (String)

#length (Struct)

#length (Symbol)

#line_trace_all (RubyVM::InstructionSequence)

#line_trace_specify (RubyVM::InstructionSequence)

#lineno (Thread::Backtrace::Location)

#lineno (TracePoint)

#lineno= (ARGF)

#lines (String)

#list (ThreadGroup)

#ljust (String)

#local_variable_defined? (Binding)

#local_variable_get (Binding)

#local_variable_set (Binding)

#local_variables (Kernel)

#localtime (Time)

#locked? (Mutex)

#lstrip (String)

#lstrip! (String)

#magnitude (Bignum)

#magnitude (Complex)

#magnitude (Fixnum)

#magnitude (Float)

#magnitude (Numeric)

#map (Enumerable)

#map (Enumerator::Lazy)

#match (Regexp)

#match (String)

#match (Symbol)

#max (Enumerable)

#max (SizedQueue)

#max= (SizedQueue)

#max_by (Enumerable)

#member? (Enumerable)

#member? (Hash)

#member? (ObjectSpace::WeakMap)

#member? (Range)

#members (Struct)

#message (Exception)

#method (Object)

#method_added (Module)

#method_defined? (Module)

#method_id (TracePoint)

#method_missing (BasicObject)

#method_removed (Module)

#method_undefined (Module)

#methods (Object)

#min (Enumerable)

#min_by (Enumerable)

#minmax (Enumerable)

#minmax_by (Enumerable)

#mode (File::Stat)

#module_eval (Module)

#module_exec (Module)

#module_function (Module)

#modulo (Bignum)

#modulo (Fixnum)

#modulo (Float)

#modulo (Numeric)

#monday? (Time)

#mtime (File::Stat)

#name (Encoding)

#name (NameError)

#name (UnboundMethod)

#named_captures (Regexp)

#names (Encoding)

#names (MatchData)

#names (Regexp)

#next (Enumerator)

#next (Integer)

#next! (String)

#next_values (Enumerator)

#nil? (NilClass)

#nlink (File::Stat)

#none? (Enumerable)

#nonzero? (Numeric)

#num_waiting (Queue)

#num_waiting (SizedQueue)

#numerator (Complex)

#numerator (Float)

#numerator (Integer)

#numerator (Numeric)

#numerator (Rational)

#object_id (Object)

#odd? (Integer)

#offset (MatchData)

#one? (Enumerable)

#options (Regexp)

#original_name (Method)

#original_name (UnboundMethod)

#owned? (File::Stat)

#owned? (FileTest)

#owned? (Mutex)

#owner (Method)

#owner (UnboundMethod)

#parameters (Method)

#parameters (Proc)

#parameters (UnboundMethod)

#partition (Enumerable)

#partition (String)

#path (RubyVM::InstructionSequence)

#path (Thread::Backtrace::Location)

#path (TracePoint)

#peek (Enumerator)

#peek_values (Enumerator)

#pending_interrupt? (Thread)

#permutation (Array)

#phase (Complex)

#phase (Numeric)

#pid (Process::Status)

#pipe? (File::Stat)

#pipe? (FileTest)

#polar (Complex)

#polar (Numeric)

#pop (SizedQueue)

#post_match (MatchData)

#pre_match (MatchData)

#pred (Integer)

#prepend (Module)

#prepend (String)

#prepend_features (Module)

#prepended (Module)

#primitive_convert (Encoding::Converter)

#primitive_errinfo (Encoding::Converter)

#print (Kernel)

#printf (Kernel)

#priority (Thread)

#priority= (Thread)

#private (Module)

#private_class_method (Module)

#private_constant (Module)

#private_instance_methods (Module)

#private_method_defined? (Module)

#private_methods (Object)

#product (Array)

#protected (Module)

#protected_instance_methods (Module)

#protected_method_defined? (Module)

#protected_methods (Object)

#public (Module)

#public_class_method (Module)

#public_constant (Module)

#public_instance_method (Module)

#public_instance_methods (Module)

#public_method (Object)

#public_method_defined? (Module)

#public_methods (Object)

#public_send (Object)

#push (SizedQueue)

#putback (Encoding::Converter)

#quo (Rational)

#raise (Kernel)

#raise (Thread)

#raised_exception (TracePoint)

#rassoc (Array)

#rationalize (Complex)

#rationalize (Float)

#rationalize (Integer)

#rationalize (NilClass)

#rationalize (Rational)

#rdev (File::Stat)

#rdev_major (File::Stat)

#rdev_minor (File::Stat)

#read_nonblock (ARGF)

#read_nonblock (IO)

#readable? (File::Stat)

#readable? (FileTest)

#readable_real? (File::Stat)

#readable_real? (FileTest)

#readagain_bytes (Encoding::InvalidByteSequenceError)

#readbyte (ARGF)

#readchar (ARGF)

#readline (ARGF)

#readline (Kernel)

#readlines (ARGF)

#readlines (IO)

#readlines (Kernel)

#readpartial (ARGF)

#readpartial (IO)

#real (Complex)

#real (Numeric)

#real? (Complex)

#real? (Numeric)

#reason (LocalJumpError)

#receiver (Method)

#rect (Complex)

#rect (Numeric)

#rectangular (Complex)

#rectangular (Numeric)

#reduce (Enumerable)

#refine (Module)

#regexp (MatchData)

#reject (Array)

#reject (Enumerable)

#reject (Enumerator::Lazy)

#reject! (Array)

#reject! (Hash)

#remainder (Bignum)

#remainder (Numeric)

#remove_class_variable (Module)

#remove_const (Module)

#remove_instance_variable (Object)

#remove_method (Module)

#repeated_combination (Array)

#repeated_permutation (Array)

#replace (Array)

#replace (Hash)

#replace (String)

#replacement (Encoding::Converter)

#replacement= (Encoding::Converter)

#replicate (Encoding)

#require (Kernel)

#require_relative (Kernel)

#respond_to? (Object)

#respond_to_missing? (Object)

#result (StopIteration)

#resume (Fiber)

#return_value (TracePoint)

#reverse (Array)

#reverse (String)

#reverse! (Array)

#reverse! (String)

#reverse_each (Array)

#reverse_each (Enumerable)

#rewind (Enumerator)

#rindex (Array)

#rindex (String)

#rjust (String)

#rotate (Array)

#rotate! (Array)

#round (Integer)

#round (Numeric)

#round (Rational)

#rpartition (String)

#rstrip (String)

#rstrip! (String)

#safe_level (Thread)

#sample (Array)

#saturday? (Time)

#scrub (String)

#scrub! (String)

#select (Array)

#select (Enumerable)

#select (Enumerator::Lazy)

#select (Kernel)

#select (Struct)

#select! (Array)

#select! (Hash)

#self (TracePoint)

#set_backtrace (Exception)

#set_encoding (ARGF)

#set_encoding (IO)

#set_trace_func (Kernel)

#set_trace_func (Thread)

#setbyte (String)

#setgid? (File::Stat)

#setgid? (FileTest)

#setuid? (File::Stat)

#setuid? (FileTest)

#shift (SizedQueue)

#shuffle (Array)

#shuffle! (Array)

#signal (ConditionVariable)

#signaled? (Process::Status)

#signo (SignalException)

#singleton_class (Object)

#singleton_class? (Module)

#singleton_method (Object)

#singleton_method_added (BasicObject)

#singleton_method_added (Numeric)

#singleton_method_removed (BasicObject)

#singleton_method_undefined (BasicObject)

#singleton_methods (Object)

#size (Enumerator)

#size (File::Stat)

#size (FileTest)

#size (MatchData)

#size (ObjectSpace::WeakMap)

#size? (File::Stat)

#size? (FileTest)

#sleep (Kernel)

#slice (String)

#slice (Symbol)

#slice! (Array)

#slice! (String)

#slice_before (Enumerable)

#slice_before (Enumerator::Lazy)

#socket? (File::Stat)

#socket? (FileTest)

#sort (Enumerable)

#sort_by (Enumerable)

#sort_by! (Array)

#source (Regexp)

#source_encoding (Encoding::Converter)

#source_encoding (Encoding::InvalidByteSequenceError)

#source_encoding (Encoding::UndefinedConversionError)

#source_encoding_name (Encoding::InvalidByteSequenceError)

#source_encoding_name (Encoding::UndefinedConversionError)

#source_location (Method)

#source_location (Proc)

#source_location (UnboundMethod)

#spawn (Kernel)

#split (String)

#sprintf (Kernel)

#squeeze (String)

#squeeze! (String)

#srand (Kernel)

#start_with? (String)

#status (SystemExit)

#status (Thread)

#step (Numeric)

#sticky? (File::Stat)

#sticky? (FileTest)

#stop? (Thread)

#stopped? (Process::Status)

#stopsig (Process::Status)

#strftime (Time)

#string (MatchData)

#strip (String)

#strip! (String)

#succ (Integer)

#succ! (String)

#success? (Process::Status)

#success? (SystemExit)

#sunday? (Time)

#superclass (Class)

#swapcase (String)

#swapcase (Symbol)

#swapcase! (String)

#symlink? (File::Stat)

#symlink? (FileTest)

#synchronize (Mutex)

#syscall (Kernel)

#system (Kernel)

#taint (Object)

#tainted? (Object)

#take (Enumerable)

#take (Enumerator::Lazy)

#take_while (Array)

#take_while (Enumerable)

#take_while (Enumerator::Lazy)

#terminate (Thread)

#termsig (Process::Status)

#thread_variable? (Thread)

#thread_variable_get (Thread)

#thread_variable_set (Thread)

#thread_variables (Thread)

#throw (Kernel)

#thursday? (Time)

#times (Integer)

#to_a (Enumerable)

#to_a (MatchData)

#to_a (NilClass)

#to_a (RubyVM::InstructionSequence)

#to_ary (Array)

#to_c (Complex)

#to_c (NilClass)

#to_c (Numeric)

#to_enum (Enumerator::Lazy)

#to_enum (Object)

#to_f (Complex)

#to_f (NilClass)

#to_f (Rational)

#to_h (Enumerable)

#to_h (NilClass)

#to_hash (Hash)

#to_i (Complex)

#to_i (Integer)

#to_i (NilClass)

#to_i (Process::Status)

#to_i (Rational)

#to_int (Float)

#to_int (Integer)

#to_int (Numeric)

#to_path (File)

#to_proc (Method)

#to_proc (Proc)

#to_proc (Symbol)

#to_r (Complex)

#to_r (Integer)

#to_r (NilClass)

#to_r (Rational)

#to_s (Complex)

#to_s (Encoding)

#to_s (Exception)

#to_s (FalseClass)

#to_s (MatchData)

#to_s (NilClass)

#to_s (Process::Status)

#to_s (Rational)

#to_s (Thread::Backtrace::Location)

#to_s (TrueClass)

#to_s (UnboundMethod)

#to_str (String)

#to_sym (String)

#to_sym (Symbol)

#to_write_io (ARGF)

#tr_s! (String)

#trace_var (Kernel)

#transfer (Fiber)

#transpose (Array)

#truncate (File)

#truncate (Float)

#truncate (Integer)

#truncate (Numeric)

#truncate (Rational)

#trust (Object)

#try_lock (Mutex)

#tuesday? (Time)

#tv_nsec (Time)

#tv_usec (Time)

#uid (File::Stat)

#unbind (Method)

#undef_method (Module)

#ungetbyte (IO)

#unlock (Mutex)

#unpack (String)

#unshift (Array)

#untaint (Object)

#untrace_var (Kernel)

#untrust (Object)

#untrusted? (Object)

#upcase (String)

#upcase (Symbol)

#upcase! (String)

#upto (Integer)

#using (Module)

#utc_offset (Time)

#valid_encoding? (String)

#value (Thread)

#values (ObjectSpace::WeakMap)

#values (Struct)

#values_at (Array)

#values_at (Hash)

#values_at (MatchData)

#values_at (Struct)

#wait (ConditionVariable)

#wakeup (Thread)

#wednesday? (Time)

#with_index (Enumerator)

#with_object (Enumerator)

#world_readable? (File::Stat)

#world_readable? (FileTest)

#world_writable? (File::Stat)

#world_writable? (FileTest)

#writable? (File::Stat)

#writable? (FileTest)

#writable_real? (File::Stat)

#writable_real? (FileTest)

#write_nonblock (IO)

#zero? (File::Stat)

#zero? (FileTest)

#zero? (Fixnum)

#zero? (Numeric)

#zip (Enumerable)

#zip (Enumerator::Lazy)

#| (FalseClass)