Ruby 1.9.2

Methods

::=== (SystemCallError)

::DEBUG (Thread)

::DEBUG= (Thread)

::[] (Array)

::[] (Dir)

::[] (Hash)

::_id2ref (ObjectSpace)

::_load (Time)

::abort (Process)

::abort_on_exception (Thread)

::abort_on_exception= (Thread)

::absolute_path (File)

::acos (Math)

::acosh (Math)

::aliases (Encoding)

::all_symbols (Symbol)

::asciicompat_encoding (Encoding::Converter)

::asin (Math)

::asinh (Math)

::at (Time)

::atan (Math)

::atan2 (Math)

::atanh (Math)

::atime (File)

::basename (File)

::binread (IO)

::blockdev? (File)

::cbrt (Math)

::change_privilege (Process::GID)

::change_privilege (Process::UID)

::chardev? (File)

::chdir (Dir)

::chmod (File)

::chown (File)

::chroot (Dir)

::clear (GC::Profiler)

::compatible? (Encoding)

::compile (Regexp)

::compile (RubyVM::InstructionSequence)

::compile_file (RubyVM::InstructionSequence)

::compile_option (RubyVM::InstructionSequence)

::compile_option= (RubyVM::InstructionSequence)

::constants (Module)

::copy_stream (IO)

::cos (Math)

::cosh (Math)

::count (GC)

::count_objects (ObjectSpace)

::ctime (File)

::current (Fiber)

::current (Thread)

::daemon (Process)

::default_external (Encoding)

::default_external= (Encoding)

::default_internal (Encoding)

::default_internal= (Encoding)

::define_finalizer (ObjectSpace)

::delete (Dir)

::delete (File)

::detach (Process)

::directory? (File)

::dirname (File)

::disable (GC)

::disable (GC::Profiler)

::disasm (RubyVM::InstructionSequence)

::disassemble (RubyVM::InstructionSequence)

::dump (Marshal)

::each_object (ObjectSpace)

::egid (Process)

::egid= (Process)

::eid (Process::GID)

::eid (Process::UID)

::enable (GC)

::enable (GC::Profiler)

::enabled? (GC::Profiler)

::entries (Dir)

::erf (Math)

::erfc (Math)

::escape (Regexp)

::euid (Process)

::euid= (Process)

::exception (Exception)

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

::file? (File)

::find (Encoding)

::fnmatch (File)

::fnmatch? (File)

::for_fd (IO)

::foreach (Dir)

::foreach (IO)

::fork (Process)

::fork (Thread)

::frexp (Math)

::ftype (File)

::gamma (Math)

::garbage_collect (ObjectSpace)

::getegid (Process::Sys)

::geteuid (Process::Sys)

::getgid (Process::Sys)

::getpgid (Process)

::getpgrp (Process)

::getpriority (Process)

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

::home (Dir)

::hypot (Math)

::identical? (File)

::initgroups (Process)

::issetugid (Process::Sys)

::join (File)

::kill (Process)

::kill (Thread)

::last_match (Regexp)

::lchmod (File)

::lchown (File)

::ldexp (Math)

::lgamma (Math)

::link (File)

::list (Encoding)

::list (Signal)

::list (Thread)

::load (Marshal)

::load (RubyVM::InstructionSequence)

::local (Time)

::locale_charmap (Encoding)

::log (Math)

::log10 (Math)

::log2 (Math)

::lstat (File)

::main (Thread)

::malloc_allocated_size (GC)

::malloc_allocations (GC)

::maxgroups (Process)

::maxgroups= (Process)

::mkdir (Dir)

::mktime (Time)

::mtime (File)

::name_list (Encoding)

::nesting (Module)

::new (Array)

::new (BasicObject)

::new (Class)

::new (Dir)

::new (Encoding::Converter)

::new (Enumerator)

::new (Exception)

::new (File)

::new (File::Stat)

::new (Hash)

::new (IO)

::new (Module)

::new (Mutex)

::new (NameError)

::new (NoMethodError)

::new (Proc)

::new (Random)

::new (Range)

::new (Regexp)

::new (RubyVM::InstructionSequence)

::new (SignalException)

::new (String)

::new (Struct)

::new (SystemCallError)

::new (SystemExit)

::new (Time)

::new_seed (Random)

::now (Time)

::open (Dir)

::open (File)

::open (IO)

::owned? (File)

::pass (Thread)

::path (File)

::pid (Process)

::pipe (IO)

::pipe? (File)

::polar (Complex)

::popen (IO)

::ppid (Process)

::pwd (Dir)

::quote (Regexp)

::rand (Random)

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

::rename (File)

::report (GC::Profiler)

::restore (Marshal)

::result (GC::Profiler)

::rid (Process::GID)

::rid (Process::UID)

::rmdir (Dir)

::search_convpath (Encoding::Converter)

::select (IO)

::setegid (Process::Sys)

::seteuid (Process::Sys)

::setgid (Process::Sys)

::setgid? (File)

::setpgid (Process)

::setpgrp (Process)

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

::sin (Math)

::sinh (Math)

::size (File)

::size? (File)

::socket? (File)

::spawn (Process)

::split (File)

::sqrt (Math)

::srand (Random)

::start (GC)

::start (Thread)

::stat (File)

::sticky? (File)

::stop (Thread)

::stress (GC)

::stress= (GC)

::switch (Process::GID)

::switch (Process::UID)

::symlink (File)

::symlink? (File)

::sysopen (IO)

::tan (Math)

::tanh (Math)

::times (Process)

::total_time (GC::Profiler)

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

::utc (Time)

::utime (File)

::wait (Process)

::wait2 (Process)

::waitall (Process)

::waitpid (Process)

::waitpid2 (Process)

::world_readable? (File)

::world_writable? (File)

::writable? (File)

::writable_real? (File)

::yield (Fiber)

::zero? (File)

#! (BasicObject)

#!= (BasicObject)

#!~ (Object)

#% (Bignum)

#% (Fixnum)

#% (Float)

#% (Numeric)

#% (String)

#& (Array)

#& (Bignum)

#& (FalseClass)

#& (Fixnum)

#& (NilClass)

#& (Process::Status)

#& (TrueClass)

#* (Array)

#* (Bignum)

#* (Complex)

#* (Fixnum)

#* (Float)

#* (Rational)

#* (String)

#** (Bignum)

#** (Complex)

#** (Fixnum)

#** (Float)

#** (Rational)

#+ (Array)

#+ (Bignum)

#+ (Complex)

#+ (Fixnum)

#+ (Float)

#+ (Rational)

#+ (String)

#+ (Time)

#+@ (Numeric)

#- (Array)

#- (Bignum)

#- (Complex)

#- (Fixnum)

#- (Float)

#- (Rational)

#- (Time)

#-@ (Bignum)

#-@ (Complex)

#-@ (Fixnum)

#-@ (Float)

#-@ (Numeric)

#/ (Bignum)

#/ (Complex)

#/ (Fixnum)

#/ (Float)

#/ (Rational)

#< (Bignum)

#< (Comparable)

#< (Fixnum)

#< (Float)

#< (Module)

#<< (Array)

#<< (Bignum)

#<< (Fixnum)

#<< (IO)

#<< (String)

#<= (Bignum)

#<= (Comparable)

#<= (Fixnum)

#<= (Float)

#<= (Module)

#<=> (Array)

#<=> (Bignum)

#<=> (File::Stat)

#<=> (Fixnum)

#<=> (Float)

#<=> (Module)

#<=> (Numeric)

#<=> (Rational)

#<=> (String)

#<=> (Symbol)

#<=> (Time)

#== (Array)

#== (BasicObject)

#== (Bignum)

#== (Comparable)

#== (Complex)

#== (Exception)

#== (Fixnum)

#== (Float)

#== (Hash)

#== (MatchData)

#== (Method)

#== (Module)

#== (Proc)

#== (Process::Status)

#== (Random)

#== (Range)

#== (Rational)

#== (Regexp)

#== (String)

#== (Struct)

#== (Symbol)

#== (UnboundMethod)

#=== (Bignum)

#=== (Fixnum)

#=== (Float)

#=== (Module)

#=== (Object)

#=== (Proc)

#=== (Range)

#=== (Regexp)

#=== (String)

#=== (Symbol)

#=~ (Object)

#=~ (Regexp)

#=~ (String)

#=~ (Symbol)

#> (Bignum)

#> (Comparable)

#> (Fixnum)

#> (Float)

#> (Module)

#>= (Bignum)

#>= (Comparable)

#>= (Fixnum)

#>= (Float)

#>= (Module)

#>> (Bignum)

#>> (Fixnum)

#>> (Process::Status)

#Array (Kernel)

#Complex (Kernel)

#Float (Kernel)

#Integer (Kernel)

#Rational (Kernel)

#String (Kernel)

#[] (Array)

#[] (Bignum)

#[] (Continuation)

#[] (Fixnum)

#[] (Hash)

#[] (MatchData)

#[] (Method)

#[] (Proc)

#[] (String)

#[] (Struct)

#[] (Symbol)

#[] (Thread)

#[]= (Array)

#[]= (Hash)

#[]= (String)

#[]= (Struct)

#[]= (Thread)

#^ (Bignum)

#^ (FalseClass)

#^ (Fixnum)

#^ (NilClass)

#^ (TrueClass)

#__callee__ (Kernel)

#__id__ (Object)

#__method__ (Kernel)

#__send__ (BasicObject)

#_dump (Time)

#` (Kernel)

#abort (Kernel)

#abort_on_exception (Thread)

#abort_on_exception= (Thread)

#abs (Bignum)

#abs (Complex)

#abs (Fixnum)

#abs (Float)

#abs (Numeric)

#abs2 (Complex)

#abs2 (Numeric)

#add (ThreadGroup)

#add_trace_func (Thread)

#alias_method (Module)

#alive? (Fiber)

#alive? (Thread)

#all? (Enumerable)

#allocate (Class)

#ancestors (Module)

#angle (Complex)

#angle (Float)

#angle (Numeric)

#any? (Enumerable)

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

#backtrace (Exception)

#backtrace (Thread)

#begin (MatchData)

#begin (Range)

#between? (Comparable)

#bind (UnboundMethod)

#binding (Kernel)

#binding (Proc)

#binmode (ARGF)

#binmode (IO)

#binmode? (ARGF)

#binmode? (IO)

#blksize (File::Stat)

#block_given? (Kernel)

#blockdev? (File::Stat)

#blockdev? (FileTest)

#blocks (File::Stat)

#bytes (ARGF)

#bytes (IO)

#bytes (Random)

#bytes (String)

#bytesize (String)

#call (Continuation)

#call (Method)

#call (Proc)

#callcc (Kernel)

#caller (Kernel)

#capitalize (String)

#capitalize (Symbol)

#capitalize! (String)

#captures (MatchData)

#casecmp (String)

#casecmp (Symbol)

#casefold? (Regexp)

#catch (Kernel)

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

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

#clone (Method)

#clone (Object)

#clone (UnboundMethod)

#close (ARGF)

#close (Dir)

#close (IO)

#close_on_exec= (IO)

#close_on_exec? (IO)

#close_read (IO)

#close_write (IO)

#closed? (ARGF)

#closed? (IO)

#codepoints (IO)

#codepoints (String)

#coerce (Bignum)

#coerce (Float)

#coerce (Numeric)

#collect (Array)

#collect (Enumerable)

#collect! (Array)

#collect_concat (Enumerable)

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

#count (Enumerable)

#count (String)

#cover? (Range)

#crypt (String)

#ctime (File)

#ctime (File::Stat)

#ctime (Time)

#curry (Proc)

#cycle (Array)

#cycle (Enumerable)

#day (Time)

#default (Hash)

#default= (Hash)

#default_proc (Hash)

#default_proc= (Hash)

#define_method (Module)

#define_singleton_method (Object)

#delete (Array)

#delete (Hash)

#delete (String)

#delete! (String)

#delete_at (Array)

#delete_if (Array)

#delete_if (Hash)

#denominator (Complex)

#denominator (Float)

#denominator (Integer)

#denominator (Numeric)

#denominator (Rational)

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

#disasm (RubyVM::InstructionSequence)

#disassemble (RubyVM::InstructionSequence)

#display (Object)

#div (Bignum)

#div (Fixnum)

#div (Numeric)

#divmod (Bignum)

#divmod (Fixnum)

#divmod (Float)

#divmod (Numeric)

#downcase (String)

#downcase (Symbol)

#downcase! (String)

#downto (Integer)

#drop (Array)

#drop (Enumerable)

#drop_while (Array)

#drop_while (Enumerable)

#dst? (Time)

#dummy? (Encoding)

#dump (String)

#dup (Object)

#each (ARGF)

#each (Array)

#each (Dir)

#each (Enumerator)

#each (Hash)

#each (IO)

#each (Range)

#each (Struct)

#each_byte (ARGF)

#each_byte (IO)

#each_byte (String)

#each_char (ARGF)

#each_char (IO)

#each_char (String)

#each_codepoint (IO)

#each_codepoint (String)

#each_cons (Enumerable)

#each_entry (Enumerable)

#each_index (Array)

#each_key (Hash)

#each_line (ARGF)

#each_line (IO)

#each_line (String)

#each_pair (Hash)

#each_pair (Struct)

#each_slice (Enumerable)

#each_value (Hash)

#each_with_index (Enumerable)

#each_with_index (Enumerator)

#each_with_object (Enumerable)

#each_with_object (Enumerator)

#empty? (Array)

#empty? (Hash)

#empty? (String)

#empty? (Symbol)

#enclose (ThreadGroup)

#enclosed? (ThreadGroup)

#encode (String)

#encode! (String)

#encoding (Regexp)

#encoding (String)

#encoding (Symbol)

#end (MatchData)

#end (Range)

#end_with? (String)

#entries (Enumerable)

#enum_for (Object)

#eof (ARGF)

#eof (IO)

#eof? (ARGF)

#eof? (IO)

#eql? (Array)

#eql? (Bignum)

#eql? (Float)

#eql? (Hash)

#eql? (MatchData)

#eql? (Method)

#eql? (Numeric)

#eql? (Object)

#eql? (Proc)

#eql? (Range)

#eql? (Regexp)

#eql? (String)

#eql? (Struct)

#eql? (Time)

#eql? (UnboundMethod)

#equal? (BasicObject)

#errno (SystemCallError)

#error_bytes (Encoding::InvalidByteSequenceError)

#error_char (Encoding::UndefinedConversionError)

#eval (Binding)

#eval (Kernel)

#eval (RubyVM::InstructionSequence)

#even? (Bignum)

#even? (Fixnum)

#even? (Integer)

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

#fdiv (Complex)

#fdiv (Fixnum)

#fdiv (Float)

#fdiv (Numeric)

#fdiv (Rational)

#feed (Enumerator)

#fetch (Array)

#fetch (Hash)

#file (ARGF)

#file? (File::Stat)

#file? (FileTest)

#filename (ARGF)

#fileno (ARGF)

#fileno (IO)

#fill (Array)

#find (Enumerable)

#find_all (Enumerable)

#find_index (Array)

#find_index (Enumerable)

#finish (Encoding::Converter)

#finite? (Float)

#first (Array)

#first (Enumerable)

#first (Range)

#fixed_encoding? (Regexp)

#flat_map (Enumerable)

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

#friday? (Time)

#frozen? (Array)

#frozen? (Object)

#fsync (IO)

#ftype (File::Stat)

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

#grep (Enumerable)

#group (Thread)

#group_by (Enumerable)

#grpowned? (File::Stat)

#grpowned? (FileTest)

#gsub (Kernel)

#gsub (String)

#gsub! (String)

#has_key? (Hash)

#has_value? (Hash)

#hash (Array)

#hash (Bignum)

#hash (Float)

#hash (Hash)

#hash (MatchData)

#hash (Method)

#hash (Object)

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

#include? (String)

#included (Module)

#included_modules (Module)

#incomplete_input? (Encoding::InvalidByteSequenceError)

#index (Array)

#index (String)

#infinite? (Float)

#inherited (Class)

#initialize_copy (Array)

#initialize_copy (Hash)

#initialize_copy (String)

#inject (Enumerable)

#ino (File::Stat)

#inplace_mode (ARGF)

#inplace_mode= (ARGF)

#insert (Array)

#insert (String)

#insert_output (Encoding::Converter)

#inspect (Array)

#inspect (Complex)

#inspect (Dir)

#inspect (Encoding)

#inspect (Encoding::Converter)

#inspect (Enumerator)

#inspect (Exception)

#inspect (File::Stat)

#inspect (Hash)

#inspect (IO)

#inspect (MatchData)

#inspect (Method)

#inspect (NilClass)

#inspect (Object)

#inspect (Process::Status)

#inspect (Range)

#inspect (Rational)

#inspect (Regexp)

#inspect (RubyVM::InstructionSequence)

#inspect (String)

#inspect (Struct)

#inspect (Symbol)

#inspect (Thread)

#inspect (Time)

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

#join (Array)

#join (Thread)

#keep_if (Array)

#keep_if (Hash)

#key (Hash)

#key? (Hash)

#key? (Thread)

#keys (Hash)

#keys (Thread)

#kill (Thread)

#kind_of? (Object)

#lambda (Kernel)

#lambda? (Proc)

#last (Array)

#last (Range)

#last_error (Encoding::Converter)

#lcm (Integer)

#length (Array)

#length (Hash)

#length (MatchData)

#length (String)

#length (Struct)

#length (Symbol)

#lineno (ARGF)

#lineno (IO)

#lineno= (ARGF)

#lineno= (IO)

#lines (ARGF)

#lines (IO)

#lines (String)

#list (ThreadGroup)

#ljust (String)

#load (Kernel)

#local_variables (Kernel)

#localtime (Time)

#lock (Mutex)

#locked? (Mutex)

#loop (Kernel)

#lstat (File)

#lstrip (String)

#lstrip! (String)

#magnitude (Bignum)

#magnitude (Complex)

#magnitude (Fixnum)

#magnitude (Float)

#magnitude (Numeric)

#map (Array)

#map (Enumerable)

#map! (Array)

#marshal_dump (Time)

#marshal_load (Time)

#match (Regexp)

#match (String)

#match (Symbol)

#max (Enumerable)

#max (Range)

#max_by (Enumerable)

#mday (Time)

#member? (Enumerable)

#member? (Hash)

#member? (Range)

#members (Struct)

#merge (Hash)

#merge! (Hash)

#message (Exception)

#method (Object)

#method_added (Module)

#method_defined? (Module)

#method_missing (BasicObject)

#method_removed (Module)

#method_undefined (Module)

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

#modulo (Fixnum)

#modulo (Float)

#modulo (Numeric)

#mon (Time)

#monday? (Time)

#month (Time)

#mtime (File)

#mtime (File::Stat)

#name (Encoding)

#name (Method)

#name (Module)

#name (NameError)

#name (UnboundMethod)

#named_captures (Regexp)

#names (Encoding)

#names (MatchData)

#names (Regexp)

#nan? (Float)

#new (Class)

#next (Enumerator)

#next (Integer)

#next (String)

#next (Symbol)

#next! (String)

#next_values (Enumerator)

#nil? (NilClass)

#nil? (Object)

#nlink (File::Stat)

#none? (Enumerable)

#nonzero? (Numeric)

#nsec (Time)

#numerator (Complex)

#numerator (Float)

#numerator (Integer)

#numerator (Numeric)

#numerator (Rational)

#object_id (Object)

#oct (String)

#odd? (Bignum)

#odd? (Fixnum)

#odd? (Integer)

#offset (MatchData)

#one? (Enumerable)

#open (Kernel)

#options (Regexp)

#ord (Integer)

#ord (String)

#owned? (File::Stat)

#owned? (FileTest)

#owner (Method)

#owner (UnboundMethod)

#p (Kernel)

#pack (Array)

#parameters (Method)

#parameters (Proc)

#parameters (UnboundMethod)

#partition (Enumerable)

#partition (String)

#path (ARGF)

#path (Dir)

#path (File)

#peek (Enumerator)

#peek_values (Enumerator)

#permutation (Array)

#phase (Complex)

#phase (Float)

#phase (Numeric)

#pid (IO)

#pid (Process::Status)

#pipe? (File::Stat)

#pipe? (FileTest)

#polar (Complex)

#polar (Numeric)

#pop (Array)

#pos (ARGF)

#pos (Dir)

#pos (IO)

#pos= (ARGF)

#pos= (Dir)

#pos= (IO)

#post_match (MatchData)

#pre_match (MatchData)

#pred (Integer)

#primitive_convert (Encoding::Converter)

#primitive_errinfo (Encoding::Converter)

#print (IO)

#print (Kernel)

#printf (IO)

#printf (Kernel)

#priority (Thread)

#priority= (Thread)

#private (Module)

#private_class_method (Module)

#private_instance_methods (Module)

#private_method_defined? (Module)

#proc (Kernel)

#product (Array)

#protected (Module)

#protected_instance_methods (Module)

#protected_method_defined? (Module)

#public (Module)

#public_class_method (Module)

#public_instance_method (Module)

#public_instance_methods (Module)

#public_method (Object)

#public_method_defined? (Module)

#public_send (Object)

#push (Array)

#putback (Encoding::Converter)

#putc (IO)

#putc (Kernel)

#puts (IO)

#puts (Kernel)

#quo (Complex)

#quo (Float)

#quo (Numeric)

#quo (Rational)

#raise (Kernel)

#raise (Thread)

#rand (Kernel)

#rand (Random)

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

#rect (Complex)

#rect (Numeric)

#rectangular (Complex)

#rectangular (Numeric)

#reduce (Enumerable)

#regexp (MatchData)

#rehash (Hash)

#reject (Array)

#reject (Enumerable)

#reject (Hash)

#reject! (Array)

#reject! (Hash)

#remainder (Bignum)

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

#require (Kernel)

#require_relative (Kernel)

#respond_to? (Object)

#respond_to_missing? (Object)

#result (StopIteration)

#resume (Fiber)

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

#sec (Time)

#seed (Random)

#seek (ARGF)

#seek (Dir)

#seek (IO)

#select (Array)

#select (Enumerable)

#select (Hash)

#select (Kernel)

#select (Struct)

#select! (Array)

#select! (Hash)

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

#shuffle (Array)

#shuffle! (Array)

#signaled? (Process::Status)

#signo (SignalException)

#singleton_class (Object)

#singleton_method_added (BasicObject)

#singleton_method_added (Numeric)

#singleton_method_removed (BasicObject)

#singleton_method_undefined (BasicObject)

#singleton_methods (Object)

#size (Array)

#size (Bignum)

#size (File)

#size (File::Stat)

#size (FileTest)

#size (Fixnum)

#size (Hash)

#size (MatchData)

#size (String)

#size (Struct)

#size (Symbol)

#size? (File::Stat)

#size? (FileTest)

#skip (ARGF)

#sleep (Kernel)

#sleep (Mutex)

#slice (Array)

#slice (String)

#slice (Symbol)

#slice! (Array)

#slice! (String)

#slice_before (Enumerable)

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

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

#succ (Integer)

#succ (String)

#succ (Symbol)

#succ (Time)

#succ! (String)

#success? (Process::Status)

#success? (SystemExit)

#sum (String)

#sunday? (Time)

#superclass (Class)

#swapcase (String)

#swapcase (Symbol)

#swapcase! (String)

#symlink? (File::Stat)

#symlink? (FileTest)

#sync (IO)

#sync= (IO)

#syscall (Kernel)

#sysread (IO)

#sysseek (IO)

#system (Kernel)

#syswrite (IO)

#taint (Object)

#tainted? (Object)

#take (Array)

#take (Enumerable)

#take_while (Array)

#take_while (Enumerable)

#tap (Object)

#tell (ARGF)

#tell (Dir)

#tell (IO)

#terminate (Thread)

#termsig (Process::Status)

#test (Kernel)

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

#to_a (Time)

#to_ary (Array)

#to_c (NilClass)

#to_c (Numeric)

#to_c (String)

#to_enum (Object)

#to_f (Bignum)

#to_f (Complex)

#to_f (Fixnum)

#to_f (Float)

#to_f (NilClass)

#to_f (Rational)

#to_f (String)

#to_f (Time)

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

#to_s (Complex)

#to_s (Encoding)

#to_s (Exception)

#to_s (FalseClass)

#to_s (Fixnum)

#to_s (Float)

#to_s (Hash)

#to_s (MatchData)

#to_s (Method)

#to_s (Module)

#to_s (NameError)

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

#to_s (TrueClass)

#to_s (UnboundMethod)

#to_str (String)

#to_sym (String)

#to_sym (Symbol)

#tr (String)

#tr! (String)

#tr_s (String)

#tr_s! (String)

#trace_var (Kernel)

#transfer (Fiber)

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

#ungetbyte (IO)

#ungetc (IO)

#uniq (Array)

#uniq! (Array)

#unlock (Mutex)

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

#utc (Time)

#utc? (Time)

#utc_offset (Time)

#valid_encoding? (String)

#value (Thread)

#value? (Hash)

#values (Hash)

#values (Struct)

#values_at (Array)

#values_at (Hash)

#values_at (MatchData)

#values_at (Struct)

#wakeup (Thread)

#warn (Kernel)

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

#write_nonblock (IO)

#yday (Time)

#year (Time)

#yield (Proc)

#zero? (File::Stat)

#zero? (FileTest)

#zero? (Fixnum)

#zero? (Float)

#zero? (Numeric)

#zip (Array)

#zip (Enumerable)

#zone (Time)

#| (Array)

#| (Bignum)

#| (FalseClass)

#| (Fixnum)

#| (NilClass)

#| (TrueClass)

#~ (Bignum)

#~ (Complex)

#~ (Fixnum)

#~ (Regexp)