Files

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

.test/rdoc/test.ja.rdoc

CONTRIBUTING.md

COPYING.ja

Makefile.in

README.EXT

README.EXT.ja

README.ja.md

README.md

common.mk

configure.ac

doc/contributing.rdoc

doc/contributors.rdoc

doc/dtrace_probes.rdoc

doc/extension.ja.rdoc

doc/extension.rdoc

doc/globals.rdoc

doc/keywords.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

gems/minitest-5.10.3/History.rdoc

gems/minitest-5.10.3/README.rdoc

gems/power_assert-1.1.1/README.rdoc

gems/rake-12.3.0/CONTRIBUTING.rdoc

gems/rake-12.3.0/History.rdoc

gems/rake-12.3.0/README.rdoc

gems/rake-12.3.0/doc/command_line_usage.rdoc

gems/rake-12.3.0/doc/glossary.rdoc

gems/rake-12.3.0/doc/proto_rake.rdoc

gems/rake-12.3.0/doc/rakefile.rdoc

gems/rake-12.3.0/doc/rational.rdoc

ia64.s

lex.c.blt

node_name.inc

sample/drb/README.ja.rdoc

sample/drb/README.rdoc

Classes

CARGF

CArgumentError

CArray

CBasicObject

CBinding

CClass

CClosedQueueError

MComparable

CComplex

CComplex::compatible

CConditionVariable

CContinuation

CData

CDir

CENV

CEOFError

CEncoding

CEncoding::CompatibilityError

CEncoding::Converter

CEncoding::ConverterNotFoundError

CEncoding::InvalidByteSequenceError

CEncoding::UndefinedConversionError

CEncodingError

MEnumerable

CEnumerator

CEnumerator::Generator

CEnumerator::Lazy

CEnumerator::Yielder

MErrno

CException

CFalseClass

CFiber

CFiberError

CFile

MFile::File::Constants

MFile::File::Constants

CFile::Stat

MFileTest

CFloat

CFloatDomainError

CFrozenError

MGC

MGC::Profiler

CHash

CIO

CIO::EAGAINWaitReadable

CIO::EAGAINWaitWritable

CIO::EINPROGRESSWaitReadable

CIO::EINPROGRESSWaitWritable

CIO::EWOULDBLOCKWaitReadable

CIO::EWOULDBLOCKWaitWritable

MIO::WaitReadable

MIO::WaitWritable

CIOError

CIndexError

CInteger

CInterrupt

MKernel

CKeyError

CLoadError

CLocalJumpError

MMarshal

CMatchData

MMath

CMath::DomainError

CMethod

CModule

CMutex

CNameError

CNilClass

CNoMemoryError

CNoMethodError

CNotImplementedError

CNumeric

CObject

MObjectSpace

CObjectSpace::WeakMap

CProc

MProcess

MProcess::GID

CProcess::Status

MProcess::Sys

MProcess::UID

CProcess::Waiter

CQueue

CRandom

MRandom::Formatter

CRange

CRangeError

CRational

CRational::compatible

CRegexp

CRegexpError

CRipper

CRubyVM

CRubyVM::InstructionSequence

CRuntimeError

CScriptError

CSecurityError

MSignal

CSignalException

CSizedQueue

CStandardError

CStopIteration

CString

CStruct

CSymbol

CSyntaxError

CSystemCallError

CSystemExit

CSystemStackError

CThread

CThread::Backtrace

CThread::Backtrace::Location

CThreadError

CThreadGroup

CTime

CTracePoint

CTrueClass

CTypeError

CUnboundMethod

CUncaughtThrowError

MUnicodeNormalize

MWarning

CWarning::buffer

CZeroDivisionError

Cfatal

Methods

::=== (SystemCallError)

::DEBUG (Thread)

::DEBUG= (Thread)

::[] (Array)

::[] (Dir)

::[] (ENV)

::[] (Hash)

::[]= (ENV)

::_id2ref (ObjectSpace)

::abort (Process)

::abort_on_exception (Thread)

::abort_on_exception= (Thread)

::absolute_path (File)

::acos (Math)

::acosh (Math)

::add_stress_to_class (GC)

::aliases (Encoding)

::all_symbols (Symbol)

::argv0 (Process)

::asciicompat_encoding (Encoding::Converter)

::asin (Math)

::asinh (Math)

::assoc (ENV)

::at (Time)

::atan (Math)

::atan2 (Math)

::atanh (Math)

::atime (File)

::basename (File)

::binread (IO)

::binwrite (IO)

::birthtime (File)

::blockdev? (File)

::cbrt (Math)

::change_privilege (Process::GID)

::change_privilege (Process::UID)

::chardev? (File)

::chdir (Dir)

::children (Dir)

::chmod (File)

::chown (File)

::chroot (Dir)

::clear (ENV)

::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)

::const_missing (Object)

::constants (Module)

::copy_stream (IO)

::cos (Math)

::cosh (Math)

::count (GC)

::count_objects (ObjectSpace)

::ctime (File)

::current (Fiber)

::current (Thread)

::daemon (Process)

::dedent_string (Ripper)

::default_external (Encoding)

::default_external= (Encoding)

::default_internal (Encoding)

::default_internal= (Encoding)

::define_finalizer (ObjectSpace)

::delete (Dir)

::delete (ENV)

::delete (File)

::delete_if (ENV)

::detach (Process)

::directory? (File)

::dirname (File)

::disable (GC)

::disable (GC::Profiler)

::disasm (RubyVM::InstructionSequence)

::disassemble (RubyVM::InstructionSequence)

::dump (Marshal)

::each (ENV)

::each_child (Dir)

::each_key (ENV)

::each_object (ObjectSpace)

::each_pair (ENV)

::each_value (ENV)

::egid (Process)

::egid= (Process)

::eid (Process::GID)

::eid (Process::UID)

::empty? (Dir)

::empty? (ENV)

::empty? (File)

::enable (GC)

::enable (GC::Profiler)

::enabled? (GC::Profiler)

::entries (Dir)

::erf (Math)

::erfc (Math)

::escape (Regexp)

::euid (Process)

::euid= (Process)

::exception (Exception)

::exclusive (Thread)

::exec (Process)

::executable? (File)

::executable_real? (File)

::exist? (Dir)

::exist? (File)

::exists? (Dir)

::exists? (File)

::exit (Process)

::exit (Thread)

::exit! (Process)

::exp (Math)

::expand_path (File)

::extname (File)

::fetch (ENV)

::file? (File)

::find (Encoding)

::fnmatch (File)

::fnmatch? (File)

::for_fd (IO)

::foreach (Dir)

::foreach (IO)

::fork (Process)

::fork (Thread)

::frexp (Math)

::from_name (Process::GID)

::from_name (Process::UID)

::ftype (File)

::gamma (Math)

::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)

::getwd (Dir)

::gid (Process)

::gid= (Process)

::glob (Dir)

::gm (Time)

::grant_privilege (Process::GID)

::grant_privilege (Process::UID)

::groups (Process)

::groups= (Process)

::grpowned? (File)

::handle_interrupt (Thread)

::has_key? (ENV)

::has_value? (ENV)

::home (Dir)

::hypot (Math)

::identical? (File)

::include? (ENV)

::index (ENV)

::initgroups (Process)

::inspect (ENV)

::invert (ENV)

::issetugid (Process::Sys)

::join (File)

::keep_if (ENV)

::key (ENV)

::key? (ENV)

::keys (ENV)

::kill (Process)

::kill (Thread)

::last_match (Regexp)

::last_status (Process)

::latest_gc_info (GC)

::lchmod (File)

::lchown (File)

::ldexp (Math)

::length (ENV)

::lex_state_name (Ripper)

::lgamma (Math)

::link (File)

::list (Encoding)

::list (Signal)

::list (Thread)

::load (Marshal)

::load_from_binary (RubyVM::InstructionSequence)

::load_from_binary_extra_data (RubyVM::InstructionSequence)

::local (Time)

::locale_charmap (Encoding)

::log (Math)

::log10 (Math)

::log2 (Math)

::lstat (File)

::lutime (File)

::main (Thread)

::malloc_allocated_size (GC)

::malloc_allocations (GC)

::maxgroups (Process)

::maxgroups= (Process)

::member? (ENV)

::mkdir (Dir)

::mkfifo (File)

::mktime (Time)

::mtime (File)

::name_list (Encoding)

::nesting (Module)

::new (Array)

::new (BasicObject)

::new (Class)

::new (ConditionVariable)

::new (Dir)

::new (Encoding::Converter)

::new (Enumerator)

::new (Enumerator::Lazy)

::new (Exception)

::new (File)

::new (File::Stat)

::new (Hash)

::new (IO)

::new (Module)

::new (Mutex)

::new (NameError)

::new (NoMethodError)

::new (Proc)

::new (Queue)

::new (Random)

::new (Range)

::new (Regexp)

::new (Ripper)

::new (RubyVM::InstructionSequence)

::new (SignalException)

::new (SizedQueue)

::new (String)

::new (Struct)

::new (SyntaxError)

::new (SystemCallError)

::new (SystemExit)

::new (Thread)

::new (Time)

::new (TracePoint)

::new (UncaughtThrowError)

::new_seed (Random)

::now (Time)

::of (RubyVM::InstructionSequence)

::open (Dir)

::open (File)

::open (IO)

::owned? (File)

::pass (Thread)

::path (File)

::pending_interrupt? (Thread)

::pid (Process)

::pipe (IO)

::pipe? (File)

::polar (Complex)

::popen (IO)

::ppid (Process)

::pwd (Dir)

::quote (Regexp)

::rand (Random)

::rassoc (ENV)

::raw_data (GC::Profiler)

::re_exchange (Process::GID)

::re_exchange (Process::UID)

::re_exchangeable? (Process::GID)

::re_exchangeable? (Process::UID)

::read (IO)

::readable? (File)

::readable_real? (File)

::readlines (IO)

::readlink (File)

::realdirpath (File)

::realpath (File)

::rect (Complex)

::rectangular (Complex)

::rehash (ENV)

::reject (ENV)

::reject! (ENV)

::remove_stress_to_class (GC)

::rename (File)

::replace (ENV)

::report (GC::Profiler)

::report_on_exception (Thread)

::report_on_exception= (Thread)

::restore (Marshal)

::result (GC::Profiler)

::rid (Process::GID)

::rid (Process::UID)

::rmdir (Dir)

::search_convpath (Encoding::Converter)

::select (ENV)

::select (IO)

::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)

::shift (ENV)

::sid_available? (Process::GID)

::sid_available? (Process::UID)

::signame (Signal)

::sin (Math)

::sinh (Math)

::size (ENV)

::size (File)

::size? (File)

::socket? (File)

::spawn (Process)

::split (File)

::sqrt (Integer)

::sqrt (Math)

::srand (Random)

::start (GC)

::start (Thread)

::stat (File)

::stat (GC)

::stat (RubyVM)

::stat (TracePoint)

::sticky? (File)

::stop (Thread)

::store (ENV)

::stress (GC)

::stress= (GC)

::switch (Process::GID)

::switch (Process::UID)

::symlink (File)

::symlink? (File)

::sysopen (IO)

::tan (Math)

::tanh (Math)

::times (Process)

::to_a (ENV)

::to_h (ENV)

::to_hash (ENV)

::to_s (ENV)

::to_tty? (Exception)

::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)

::umask (File)

::undefine_finalizer (ObjectSpace)

::union (Regexp)

::unlink (Dir)

::unlink (File)

::update (ENV)

::urandom (Random)

::used_modules (Module)

::utc (Time)

::utime (File)

::value? (ENV)

::values (ENV)

::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)

::write (IO)

::yield (Fiber)

::zero? (File)

#! (BasicObject)

#!= (BasicObject)

#!~ (Object)

#% (Float)

#% (Integer)

#% (Numeric)

#% (String)

#& (Array)

#& (FalseClass)

#& (Integer)

#& (NilClass)

#& (Process::Status)

#& (TrueClass)

#* (Array)

#* (Complex)

#* (Float)

#* (Integer)

#* (Rational)

#* (String)

#** (Complex)

#** (Float)

#** (Integer)

#** (Rational)

#+ (Array)

#+ (Complex)

#+ (Float)

#+ (Integer)

#+ (Rational)

#+ (String)

#+ (Time)

#+@ (Numeric)

#+@ (String)

#- (Array)

#- (Complex)

#- (Float)

#- (Integer)

#- (Rational)

#- (Time)

#-@ (Complex)

#-@ (Float)

#-@ (Integer)

#-@ (Numeric)

#-@ (Rational)

#-@ (String)

#/ (Complex)

#/ (Float)

#/ (Integer)

#/ (Rational)

#/ (String)

#< (Comparable)

#< (Float)

#< (Hash)

#< (Integer)

#< (Module)

#<< (Array)

#<< (IO)

#<< (Integer)

#<< (Queue)

#<< (SizedQueue)

#<< (String)

#<= (Comparable)

#<= (Float)

#<= (Hash)

#<= (Integer)

#<= (Module)

#<=> (Array)

#<=> (File::Stat)

#<=> (Float)

#<=> (Integer)

#<=> (Module)

#<=> (Numeric)

#<=> (Object)

#<=> (Rational)

#<=> (String)

#<=> (Symbol)

#<=> (Time)

#== (Array)

#== (BasicObject)

#== (Comparable)

#== (Complex)

#== (Encoding::Converter)

#== (Exception)

#== (Float)

#== (Hash)

#== (Integer)

#== (MatchData)

#== (Method)

#== (Module)

#== (Process::Status)

#== (Random)

#== (Range)

#== (Rational)

#== (Regexp)

#== (String)

#== (Struct)

#== (Symbol)

#== (UnboundMethod)

#=== (FalseClass)

#=== (Float)

#=== (Integer)

#=== (Method)

#=== (Module)

#=== (NilClass)

#=== (Object)

#=== (Proc)

#=== (Range)

#=== (Regexp)

#=== (String)

#=== (Symbol)

#=== (TrueClass)

#=~ (Object)

#=~ (Regexp)

#=~ (String)

#=~ (Symbol)

#> (Comparable)

#> (Float)

#> (Hash)

#> (Integer)

#> (Module)

#>= (Comparable)

#>= (Float)

#>= (Hash)

#>= (Integer)

#>= (Module)

#>> (Integer)

#>> (Process::Status)

#Array (Kernel)

#Complex (Kernel)

#Float (Kernel)

#Hash (Kernel)

#Integer (Kernel)

#Rational (Kernel)

#String (Kernel)

#[] (Array)

#[] (Continuation)

#[] (Hash)

#[] (Integer)

#[] (MatchData)

#[] (Method)

#[] (ObjectSpace::WeakMap)

#[] (Proc)

#[] (String)

#[] (Struct)

#[] (Symbol)

#[] (Thread)

#[]= (Array)

#[]= (Hash)

#[]= (ObjectSpace::WeakMap)

#[]= (String)

#[]= (Struct)

#[]= (Thread)

#^ (FalseClass)

#^ (Integer)

#^ (NilClass)

#^ (TrueClass)

#__callee__ (Kernel)

#__dir__ (Kernel)

#__id__ (BasicObject)

#__method__ (Kernel)

#__send__ (BasicObject)

#` (Kernel)

#abort (Kernel)

#abort_on_exception (Thread)

#abort_on_exception= (Thread)

#abs (Complex)

#abs (Float)

#abs (Integer)

#abs (Numeric)

#abs (Rational)

#abs2 (Complex)

#abs2 (Numeric)

#absolute_path (RubyVM::InstructionSequence)

#absolute_path (Thread::Backtrace::Location)

#add (ThreadGroup)

#add_trace_func (Thread)

#advise (IO)

#alias_method (Module)

#alive? (Fiber)

#alive? (Thread)

#all? (Enumerable)

#allbits? (Integer)

#allocate (Class)

#ancestors (Module)

#angle (Complex)

#angle (Float)

#angle (Numeric)

#any? (Array)

#any? (Enumerable)

#any? (Hash)

#anybits? (Integer)

#append (Array)

#append_features (Module)

#arg (Complex)

#arg (Float)

#arg (Numeric)

#args (NoMethodError)

#argv (ARGF)

#arity (Method)

#arity (Proc)

#arity (UnboundMethod)

#ascii_compatible? (Encoding)

#ascii_only? (String)

#asctime (Time)

#assoc (Array)

#assoc (Hash)

#at (Array)

#at_exit (Kernel)

#atime (File)

#atime (File::Stat)

#attr (Module)

#attr_accessor (Module)

#attr_reader (Module)

#attr_writer (Module)

#autoclose= (IO)

#autoclose? (IO)

#autoload (Kernel)

#autoload (Module)

#autoload? (Kernel)

#autoload? (Module)

#b (String)

#backtrace (Exception)

#backtrace (Thread)

#backtrace_locations (Exception)

#backtrace_locations (Thread)

#base_label (RubyVM::InstructionSequence)

#base_label (Thread::Backtrace::Location)

#begin (MatchData)

#begin (Range)

#between? (Comparable)

#bind (UnboundMethod)

#binding (Kernel)

#binding (Proc)

#binding (TracePoint)

#binmode (ARGF)

#binmode (IO)

#binmode? (ARGF)

#binmode? (IO)

#birthtime (File)

#birthtime (File::Stat)

#bit_length (Integer)

#blksize (File::Stat)

#block_given? (Kernel)

#blockdev? (File::Stat)

#blockdev? (FileTest)

#blocks (File::Stat)

#broadcast (ConditionVariable)

#bsearch (Array)

#bsearch (Range)

#bsearch_index (Array)

#bytes (ARGF)

#bytes (IO)

#bytes (Random)

#bytes (String)

#bytesize (String)

#byteslice (String)

#call (Continuation)

#call (Method)

#call (Proc)

#call (Symbol)

#callable_methods (Object)

#callcc (Kernel)

#callee_id (TracePoint)

#caller (Kernel)

#caller_locations (Kernel)

#capitalize (String)

#capitalize (Symbol)

#capitalize! (String)

#captures (MatchData)

#casecmp (String)

#casecmp (Symbol)

#casecmp? (String)

#casecmp? (Symbol)

#casefold? (Regexp)

#catch (Kernel)

#cause (Exception)

#ceil (Float)

#ceil (Integer)

#ceil (Numeric)

#ceil (Rational)

#center (String)

#chardev? (File::Stat)

#chardev? (FileTest)

#chars (ARGF)

#chars (IO)

#chars (String)

#chmod (File)

#chomp (Kernel)

#chomp (String)

#chomp! (String)

#chop (Kernel)

#chop (String)

#chop! (String)

#chown (File)

#chr (Integer)

#chr (String)

#chunk (Enumerable)

#chunk (Enumerator::Lazy)

#chunk_while (Enumerable)

#chunk_while (Enumerator::Lazy)

#clamp (Comparable)

#class (Object)

#class_eval (Module)

#class_exec (Module)

#class_variable_defined? (Module)

#class_variable_get (Module)

#class_variable_set (Module)

#class_variables (Module)

#clear (Array)

#clear (Hash)

#clear (Queue)

#clear (SizedQueue)

#clear (String)

#clone (Method)

#clone (Numeric)

#clone (Object)

#clone (UnboundMethod)

#close (ARGF)

#close (Dir)

#close (IO)

#close (Queue)

#close (SizedQueue)

#close_on_exec= (IO)

#close_on_exec? (IO)

#close_read (IO)

#close_write (IO)

#closed? (ARGF)

#closed? (IO)

#closed? (Queue)

#codepoints (ARGF)

#codepoints (IO)

#codepoints (String)

#coerce (Float)

#coerce (Integer)

#coerce (Numeric)

#collect (Array)

#collect (Enumerable)

#collect (Enumerator::Lazy)

#collect! (Array)

#collect_concat (Enumerable)

#collect_concat (Enumerator::Lazy)

#column (Ripper)

#combination (Array)

#compact (Array)

#compact (Hash)

#compact! (Array)

#compact! (Hash)

#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 (Array)

#count (Enumerable)

#count (String)

#cover? (Range)

#crypt (String)

#ctime (File)

#ctime (File::Stat)

#ctime (Time)

#curry (Method)

#curry (Proc)

#cycle (Array)

#cycle (Enumerable)

#day (Time)

#dedent_string (Ripper)

#default (Hash)

#default= (Hash)

#default_proc (Hash)

#default_proc= (Hash)

#define_method (Module)

#define_singleton_method (Object)

#defined_class (TracePoint)

#delete (Array)

#delete (Hash)

#delete (String)

#delete! (String)

#delete_at (Array)

#delete_if (Array)

#delete_if (Hash)

#delete_prefix (String)

#delete_prefix! (String)

#delete_suffix (String)

#delete_suffix! (String)

#denominator (Complex)

#denominator (Float)

#denominator (Integer)

#denominator (Numeric)

#denominator (Rational)

#deprecate_constant (Module)

#deq (Queue)

#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)

#dig (Array)

#dig (Hash)

#dig (Struct)

#digits (Integer)

#directory? (File::Stat)

#directory? (FileTest)

#disable (TracePoint)

#disasm (RubyVM::InstructionSequence)

#disassemble (RubyVM::InstructionSequence)

#display (Object)

#div (Integer)

#div (Numeric)

#divmod (Float)

#divmod (Integer)

#divmod (Numeric)

#do_until (Object)

#do_while (Object)

#downcase (String)

#downcase (Symbol)

#downcase! (String)

#downto (Integer)

#drop (Array)

#drop (Enumerable)

#drop (Enumerator::Lazy)

#drop_while (Array)

#drop_while (Enumerable)

#drop_while (Enumerator::Lazy)

#dst? (Time)

#dummy? (Encoding)

#dump (String)

#dup (Numeric)

#dup (Object)

#each (ARGF)

#each (Array)

#each (Dir)

#each (Enumerator)

#each (Hash)

#each (IO)

#each (Integer)

#each (ObjectSpace::WeakMap)

#each (Range)

#each (Struct)

#each_byte (ARGF)

#each_byte (IO)

#each_byte (String)

#each_char (ARGF)

#each_char (IO)

#each_char (String)

#each_child (RubyVM::InstructionSequence)

#each_codepoint (ARGF)

#each_codepoint (IO)

#each_codepoint (String)

#each_cons (Enumerable)

#each_entry (Enumerable)

#each_grapheme_cluster (String)

#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? (FileTest)

#empty? (Hash)

#empty? (Queue)

#empty? (SizedQueue)

#empty? (String)

#empty? (Symbol)

#enable (TracePoint)

#enabled? (TracePoint)

#enclose (ThreadGroup)

#enclosed? (ThreadGroup)

#encode (String)

#encode! (String)

#encoding (Regexp)

#encoding (Ripper)

#encoding (String)

#encoding (Symbol)

#end (MatchData)

#end (Range)

#end_seen? (Ripper)

#end_with? (String)

#enq (Queue)

#enq (SizedQueue)

#entries (Enumerable)

#enum_for (Enumerator::Lazy)

#enum_for (Object)

#eof (ARGF)

#eof (IO)

#eof? (ARGF)

#eof? (IO)

#eql? (Array)

#eql? (Float)

#eql? (Hash)

#eql? (MatchData)

#eql? (Method)

#eql? (Numeric)

#eql? (Object)

#eql? (Range)

#eql? (Regexp)

#eql? (String)

#eql? (Struct)

#eql? (Time)

#eql? (UnboundMethod)

#equal? (BasicObject)

#errno (SystemCallError)

#error? (Ripper)

#error_bytes (Encoding::InvalidByteSequenceError)

#error_char (Encoding::UndefinedConversionError)

#eval (Binding)

#eval (Kernel)

#eval (RubyVM::InstructionSequence)

#even? (Integer)

#event (TracePoint)

#exception (Exception)

#exclude_end? (Range)

#exec (Kernel)

#executable? (File::Stat)

#executable? (FileTest)

#executable_real? (File::Stat)

#executable_real? (FileTest)

#exist? (FileTest)

#exists? (FileTest)

#exit (Kernel)

#exit (Thread)

#exit! (Kernel)

#exit_value (LocalJumpError)

#exited? (Process::Status)

#exitstatus (Process::Status)

#extend (Object)

#extend_object (Module)

#extended (Module)

#external_encoding (ARGF)

#external_encoding (IO)

#fail (Kernel)

#fcntl (IO)

#fdatasync (IO)

#fdiv (Complex)

#fdiv (Float)

#fdiv (Integer)

#fdiv (Numeric)

#fdiv (Rational)

#feed (Enumerator)

#fetch (Array)

#fetch (Hash)

#fetch (Thread)

#fetch_values (Hash)

#file (ARGF)

#file? (File::Stat)

#file? (FileTest)

#filename (ARGF)

#filename (Ripper)

#fileno (ARGF)

#fileno (Dir)

#fileno (IO)

#fill (Array)

#finalize (ObjectSpace::WeakMap)

#find (Enumerable)

#find_all (Enumerable)

#find_all (Enumerator::Lazy)

#find_index (Array)

#find_index (Enumerable)

#finish (Encoding::Converter)

#finite? (Complex)

#finite? (Float)

#finite? (Numeric)

#first (Array)

#first (Enumerable)

#first (Range)

#first_lineno (RubyVM::InstructionSequence)

#fixed_encoding? (Regexp)

#flat_map (Enumerable)

#flat_map (Enumerator::Lazy)

#flatten (Array)

#flatten (Hash)

#flatten! (Array)

#flock (File)

#floor (Float)

#floor (Integer)

#floor (Numeric)

#floor (Rational)

#flush (IO)

#force_encoding (String)

#fork (Kernel)

#format (Kernel)

#freeze (Module)

#freeze (Object)

#freeze (String)

#friday? (Time)

#frozen? (Array)

#frozen? (Object)

#fsync (IO)

#ftype (File::Stat)

#full_message (Exception)

#garbage_collect (GC)

#gcd (Integer)

#gcdlcm (Integer)

#getbyte (ARGF)

#getbyte (IO)

#getbyte (String)

#getc (ARGF)

#getc (IO)

#getgm (Time)

#getlocal (Time)

#gets (ARGF)

#gets (IO)

#gets (Kernel)

#getutc (Time)

#gid (File::Stat)

#global_variables (Kernel)

#gmt? (Time)

#gmt_offset (Time)

#gmtime (Time)

#gmtoff (Time)

#grapheme_clusters (String)

#grep (Enumerable)

#grep (Enumerator::Lazy)

#grep_v (Enumerable)

#grep_v (Enumerator::Lazy)

#group (Thread)

#group_by (Enumerable)

#grpowned? (File::Stat)

#grpowned? (FileTest)

#gsub (Kernel)

#gsub (String)

#gsub! (String)

#h (Object)

#has_key? (Hash)

#has_value? (Hash)

#hash (Array)

#hash (Float)

#hash (Hash)

#hash (MatchData)

#hash (Method)

#hash (Proc)

#hash (Range)

#hash (Regexp)

#hash (String)

#hash (Struct)

#hash (Time)

#hash (UnboundMethod)

#hex (String)

#hour (Time)

#i (Numeric)

#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 (Array)

#index (String)

#infinite? (Complex)

#infinite? (Float)

#infinite? (Numeric)

#inherited (Class)

#initialize_copy (Array)

#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 (Complex)

#inspect (Dir)

#inspect (Encoding)

#inspect (Encoding::Converter)

#inspect (Enumerator)

#inspect (Exception)

#inspect (FalseClass)

#inspect (Fiber)

#inspect (File::Stat)

#inspect (Float)

#inspect (Hash)

#inspect (IO)

#inspect (Integer)

#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)

#invert (Hash)

#ioctl (IO)

#is_a? (Object)

#isatty (IO)

#isdst (Time)

#iterator? (Kernel)

#itself (Object)

#join (Array)

#join (Thread)

#keep_if (Array)

#keep_if (Hash)

#key (Hash)

#key (KeyError)

#key? (Hash)

#key? (ObjectSpace::WeakMap)

#key? (Thread)

#keys (Hash)

#keys (ObjectSpace::WeakMap)

#keys (Thread)

#kill (Thread)

#kind_of? (Object)

#label (RubyVM::InstructionSequence)

#label (Thread::Backtrace::Location)

#lambda (Kernel)

#lambda? (Proc)

#last (Array)

#last (Range)

#last_error (Encoding::Converter)

#lazy (Enumerable)

#lazy (Enumerator::Lazy)

#lcm (Integer)

#length (Array)

#length (Hash)

#length (MatchData)

#length (ObjectSpace::WeakMap)

#length (Queue)

#length (SizedQueue)

#length (String)

#length (Struct)

#length (Symbol)

#lineno (ARGF)

#lineno (IO)

#lineno (Ripper)

#lineno (Thread::Backtrace::Location)

#lineno (TracePoint)

#lineno= (ARGF)

#lineno= (IO)

#lines (ARGF)

#lines (IO)

#lines (String)

#list (ThreadGroup)

#ljust (String)

#load (Kernel)

#local_variable_defined? (Binding)

#local_variable_get (Binding)

#local_variable_set (Binding)

#local_variables (Binding)

#local_variables (Kernel)

#local_variables (NameError)

#localtime (Time)

#lock (Mutex)

#locked? (Mutex)

#loop (Kernel)

#lstat (File)

#lstrip (String)

#lstrip! (String)

#magnitude (Complex)

#magnitude (Float)

#magnitude (Integer)

#magnitude (Numeric)

#magnitude (Rational)

#map (Array)

#map (Enumerable)

#map (Enumerator::Lazy)

#map! (Array)

#match (Regexp)

#match (String)

#match (Symbol)

#match? (Regexp)

#match? (String)

#match? (Symbol)

#matching_methods (Object)

#max (Array)

#max (Enumerable)

#max (Range)

#max (SizedQueue)

#max= (SizedQueue)

#max_by (Enumerable)

#mday (Time)

#member? (Enumerable)

#member? (Hash)

#member? (ObjectSpace::WeakMap)

#member? (Range)

#members (Struct)

#merge (Hash)

#merge! (Hash)

#message (Exception)

#method (Object)

#method_added (Module)

#method_defined? (Module)

#method_id (TracePoint)

#method_missing (BasicObject)

#method_missing (Object)

#method_removed (Module)

#method_undefined (Module)

#methods (Object)

#min (Array)

#min (Enumerable)

#min (Range)

#min (Time)

#min_by (Enumerable)

#minmax (Enumerable)

#minmax_by (Enumerable)

#mode (File::Stat)

#module_eval (Module)

#module_exec (Module)

#module_function (Module)

#modulo (Float)

#modulo (Integer)

#modulo (Numeric)

#mon (Time)

#monday? (Time)

#month (Time)

#mtime (File)

#mtime (File::Stat)

#name (Encoding)

#name (Method)

#name (Module)

#name (NameError)

#name (Thread)

#name (UnboundMethod)

#name= (Thread)

#named_captures (MatchData)

#named_captures (Regexp)

#names (Encoding)

#names (MatchData)

#names (Regexp)

#nan? (Float)

#negative? (Float)

#negative? (Numeric)

#negative? (Rational)

#new (Class)

#next (Enumerator)

#next (Integer)

#next (String)

#next (Symbol)

#next! (String)

#next_float (Float)

#next_values (Enumerator)

#nil? (NilClass)

#nil? (Object)

#nlink (File::Stat)

#nobits? (Integer)

#none? (Enumerable)

#nonzero? (Numeric)

#nsec (Time)

#num_waiting (Queue)

#num_waiting (SizedQueue)

#numerator (Complex)

#numerator (Float)

#numerator (Integer)

#numerator (Numeric)

#numerator (Rational)

#object_id (Object)

#oct (String)

#odd? (Integer)

#offset (MatchData)

#old_inspect (Enumerator)

#old_to_s (Array)

#old_to_s (FalseClass)

#one? (Enumerable)

#open (Kernel)

#options (Regexp)

#ord (Integer)

#ord (String)

#original_name (Method)

#original_name (UnboundMethod)

#owned? (File::Stat)

#owned? (FileTest)

#owned? (Mutex)

#owner (Method)

#owner (UnboundMethod)

#p (Kernel)

#pack (Array)

#parameters (Method)

#parameters (Proc)

#parameters (UnboundMethod)

#parse (Ripper)

#partition (Enumerable)

#partition (String)

#path (ARGF)

#path (Dir)

#path (File)

#path (RubyVM::InstructionSequence)

#path (Thread::Backtrace::Location)

#path (TracePoint)

#peek (Enumerator)

#peek_values (Enumerator)

#pending_interrupt? (Thread)

#permutation (Array)

#phase (Complex)

#phase (Float)

#phase (Numeric)

#pid (IO)

#pid (Process::Status)

#pid (Process::Waiter)

#pipe? (File::Stat)

#pipe? (FileTest)

#polar (Complex)

#polar (Numeric)

#pop (Array)

#pop (Queue)

#pop (SizedQueue)

#pos (ARGF)

#pos (Dir)

#pos (IO)

#pos= (ARGF)

#pos= (Dir)

#pos= (IO)

#positive? (Float)

#positive? (Numeric)

#positive? (Rational)

#post_match (MatchData)

#pow (Integer)

#pre_match (MatchData)

#pread (IO)

#pred (Integer)

#prepend (Array)

#prepend (Module)

#prepend (String)

#prepend_features (Module)

#prepended (Module)

#prev_float (Float)

#primitive_convert (Encoding::Converter)

#primitive_errinfo (Encoding::Converter)

#print (ARGF)

#print (IO)

#print (Kernel)

#printf (ARGF)

#printf (IO)

#printf (Kernel)

#priority (Thread)

#priority= (Thread)

#private (Module)

#private_call? (NoMethodError)

#private_class_method (Module)

#private_constant (Module)

#private_instance_methods (Module)

#private_method_defined? (Module)

#private_methods (Object)

#proc (Kernel)

#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 (Array)

#push (Queue)

#push (SizedQueue)

#putback (Encoding::Converter)

#putc (ARGF)

#putc (IO)

#putc (Kernel)

#puts (ARGF)

#puts (IO)

#puts (Kernel)

#pwrite (IO)

#quo (Complex)

#quo (Float)

#quo (Numeric)

#quo (Rational)

#raise (Kernel)

#raise (Thread)

#raised_exception (TracePoint)

#rand (Kernel)

#rand (Random)

#rand (Random::Formatter)

#random_number (Random::Formatter)

#rassoc (Array)

#rassoc (Hash)

#rationalize (Complex)

#rationalize (Float)

#rationalize (Integer)

#rationalize (NilClass)

#rationalize (Rational)

#rdev (File::Stat)

#rdev_major (File::Stat)

#rdev_minor (File::Stat)

#read (ARGF)

#read (Dir)

#read (IO)

#read_nonblock (ARGF)

#read_nonblock (IO)

#readable? (File::Stat)

#readable? (FileTest)

#readable_real? (File::Stat)

#readable_real? (FileTest)

#readagain_bytes (Encoding::InvalidByteSequenceError)

#readbyte (ARGF)

#readbyte (IO)

#readchar (ARGF)

#readchar (IO)

#readline (ARGF)

#readline (IO)

#readline (Kernel)

#readlines (ARGF)

#readlines (IO)

#readlines (Kernel)

#readpartial (ARGF)

#readpartial (IO)

#real (Complex)

#real (Numeric)

#real? (Complex)

#real? (Numeric)

#reason (LocalJumpError)

#receiver (Binding)

#receiver (KeyError)

#receiver (Method)

#receiver (NameError)

#rect (Complex)

#rect (Numeric)

#rectangular (Complex)

#rectangular (Numeric)

#reduce (Enumerable)

#refine (Module)

#regexp (MatchData)

#rehash (Hash)

#reject (Array)

#reject (Enumerable)

#reject (Enumerator::Lazy)

#reject (Hash)

#reject! (Array)

#reject! (Hash)

#remainder (Integer)

#remainder (Numeric)

#remove_class_variable (Module)

#remove_const (Module)

#remove_instance_variable (Object)

#remove_method (Module)

#reopen (IO)

#repeated_combination (Array)

#repeated_permutation (Array)

#replace (Array)

#replace (Hash)

#replace (String)

#replacement (Encoding::Converter)

#replacement= (Encoding::Converter)

#replicate (Encoding)

#report_on_exception (Thread)

#report_on_exception= (Thread)

#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 (ARGF)

#rewind (Dir)

#rewind (Enumerator)

#rewind (IO)

#rindex (Array)

#rindex (String)

#rjust (String)

#rotate (Array)

#rotate! (Array)

#round (Float)

#round (Integer)

#round (Numeric)

#round (Rational)

#round (Time)

#rpartition (String)

#rstrip (String)

#rstrip! (String)

#run (Thread)

#safe_level (Thread)

#sample (Array)

#saturday? (Time)

#scan (String)

#scrub (String)

#scrub! (String)

#sec (Time)

#seed (Random)

#seek (ARGF)

#seek (Dir)

#seek (IO)

#select (Array)

#select (Enumerable)

#select (Enumerator::Lazy)

#select (Hash)

#select (Kernel)

#select (Struct)

#select! (Array)

#select! (Hash)

#self (TracePoint)

#send (Object)

#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 (Array)

#shift (Hash)

#shift (Queue)

#shift (SizedQueue)

#shortest_abbreviation (Object)

#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_removed (BasicObject)

#singleton_method_undefined (BasicObject)

#singleton_methods (Object)

#size (Array)

#size (Enumerator)

#size (File)

#size (File::Stat)

#size (FileTest)

#size (Hash)

#size (Integer)

#size (MatchData)

#size (ObjectSpace::WeakMap)

#size (Queue)

#size (Range)

#size (SizedQueue)

#size (String)

#size (Struct)

#size (Symbol)

#size? (File::Stat)

#size? (FileTest)

#skip (ARGF)

#sleep (Kernel)

#sleep (Mutex)

#slice (Array)

#slice (Hash)

#slice (String)

#slice (Symbol)

#slice! (Array)

#slice! (String)

#slice_after (Enumerable)

#slice_after (Enumerator::Lazy)

#slice_before (Enumerable)

#slice_before (Enumerator::Lazy)

#slice_when (Enumerable)

#slice_when (Enumerator::Lazy)

#socket? (File::Stat)

#socket? (FileTest)

#sort (Array)

#sort (Enumerable)

#sort! (Array)

#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)

#stat (IO)

#state (Ripper)

#status (SystemExit)

#status (Thread)

#step (Numeric)

#step (Range)

#sticky? (File::Stat)

#sticky? (FileTest)

#stop? (Thread)

#stopped? (Process::Status)

#stopsig (Process::Status)

#store (Hash)

#strftime (Time)

#string (MatchData)

#strip (String)

#strip! (String)

#sub (Kernel)

#sub (String)

#sub! (String)

#subsec (Time)

#succ (Integer)

#succ (String)

#succ (Symbol)

#succ (Time)

#succ! (String)

#success? (Process::Status)

#success? (SystemExit)

#sum (Array)

#sum (Enumerable)

#sum (String)

#sunday? (Time)

#super_method (Method)

#super_method (UnboundMethod)

#superclass (Class)

#swapcase (String)

#swapcase (Symbol)

#swapcase! (String)

#symlink? (File::Stat)

#symlink? (FileTest)

#sync (IO)

#sync= (IO)

#synchronize (Mutex)

#syscall (Kernel)

#sysread (IO)

#sysseek (IO)

#system (Kernel)

#syswrite (IO)

#tag (UncaughtThrowError)

#taint (Object)

#tainted? (Object)

#take (Array)

#take (Enumerable)

#take (Enumerator::Lazy)

#take_while (Array)

#take_while (Enumerable)

#take_while (Enumerator::Lazy)

#tap (Object)

#tell (ARGF)

#tell (Dir)

#tell (IO)

#terminate (Thread)

#termsig (Process::Status)

#test (Kernel)

#thread_variable? (Thread)

#thread_variable_get (Thread)

#thread_variable_set (Thread)

#thread_variables (Thread)

#throw (Kernel)

#thursday? (Time)

#times (Integer)

#to_a (ARGF)

#to_a (Array)

#to_a (Enumerable)

#to_a (Hash)

#to_a (MatchData)

#to_a (NilClass)

#to_a (RubyVM::InstructionSequence)

#to_a (String)

#to_a (Struct)

#to_a (Time)

#to_ary (Array)

#to_binary (RubyVM::InstructionSequence)

#to_c (Complex)

#to_c (NilClass)

#to_c (Numeric)

#to_c (String)

#to_enum (Enumerator::Lazy)

#to_enum (Object)

#to_f (Complex)

#to_f (Float)

#to_f (Integer)

#to_f (NilClass)

#to_f (Rational)

#to_f (String)

#to_f (Time)

#to_h (Array)

#to_h (Enumerable)

#to_h (Hash)

#to_h (NilClass)

#to_h (Struct)

#to_hash (Hash)

#to_i (ARGF)

#to_i (Complex)

#to_i (Float)

#to_i (IO)

#to_i (Integer)

#to_i (NilClass)

#to_i (Process::Status)

#to_i (Rational)

#to_i (String)

#to_i (Time)

#to_int (Float)

#to_int (Integer)

#to_int (Numeric)

#to_io (ARGF)

#to_io (IO)

#to_path (Dir)

#to_path (File)

#to_proc (Hash)

#to_proc (Method)

#to_proc (Proc)

#to_proc (Symbol)

#to_r (Complex)

#to_r (Float)

#to_r (Integer)

#to_r (NilClass)

#to_r (Rational)

#to_r (String)

#to_r (Time)

#to_s (ARGF)

#to_s (Array)

#to_s (Complex)

#to_s (Encoding)

#to_s (Exception)

#to_s (FalseClass)

#to_s (Fiber)

#to_s (Float)

#to_s (Hash)

#to_s (Integer)

#to_s (MatchData)

#to_s (Method)

#to_s (Module)

#to_s (NilClass)

#to_s (Object)

#to_s (Proc)

#to_s (Process::Status)

#to_s (Range)

#to_s (Rational)

#to_s (Regexp)

#to_s (String)

#to_s (Struct)

#to_s (Symbol)

#to_s (Thread)

#to_s (Thread::Backtrace::Location)

#to_s (Time)

#to_s (TrueClass)

#to_s (UnboundMethod)

#to_s (UncaughtThrowError)

#to_str (String)

#to_sym (String)

#to_sym (Symbol)

#to_write_io (ARGF)

#tr (String)

#tr! (String)

#tr_s (String)

#tr_s! (String)

#trace_points (RubyVM::InstructionSequence)

#trace_var (Kernel)

#transfer (Fiber)

#transform_keys (Hash)

#transform_keys! (Hash)

#transform_values (Hash)

#transform_values! (Hash)

#transpose (Array)

#trap (Kernel)

#truncate (File)

#truncate (Float)

#truncate (Integer)

#truncate (Numeric)

#truncate (Rational)

#trust (Object)

#try_lock (Mutex)

#tty? (IO)

#tuesday? (Time)

#tv_nsec (Time)

#tv_sec (Time)

#tv_usec (Time)

#uid (File::Stat)

#unbind (Method)

#undef_method (Module)

#undump (String)

#ungetbyte (IO)

#ungetc (IO)

#unicode_normalize (String)

#unicode_normalize! (String)

#unicode_normalized? (String)

#uniq (Array)

#uniq (Enumerable)

#uniq (Enumerator::Lazy)

#uniq! (Array)

#unlock (Mutex)

#unpack (String)

#unpack1 (String)

#unshift (Array)

#untaint (Object)

#untrace_var (Kernel)

#untrust (Object)

#untrusted? (Object)

#upcase (String)

#upcase (Symbol)

#upcase! (String)

#update (Hash)

#upto (Integer)

#upto (String)

#usec (Time)

#using (Module)

#utc (Time)

#utc? (Time)

#utc_offset (Time)

#valid_encoding? (String)

#value (Thread)

#value (UncaughtThrowError)

#value? (Hash)

#values (Hash)

#values (ObjectSpace::WeakMap)

#values (Struct)

#values_at (Array)

#values_at (Hash)

#values_at (MatchData)

#values_at (Struct)

#wait (ConditionVariable)

#wakeup (Thread)

#warn (Kernel)

#warn (Warning)

#wday (Time)

#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 (ARGF)

#write (IO)

#write (Warning::buffer)

#write_nonblock (IO)

#yday (Time)

#year (Time)

#yield (Proc)

#yield_self (Object)

#yydebug (Ripper)

#yydebug= (Ripper)

#zero? (File::Stat)

#zero? (FileTest)

#zero? (Float)

#zero? (Numeric)

#zip (Array)

#zip (Enumerable)

#zip (Enumerator::Lazy)

#zone (Time)

#| (Array)

#| (FalseClass)

#| (Integer)

#| (NilClass)

#| (TrueClass)

#~ (Complex)

#~ (Integer)

#~ (Regexp)