ARGF

ArgumentError

Array

BasicObject

Bignum

Binding

Class

Comparable

Complex

Continuation

Data

Dir

EOFError

Encoding

Encoding::CompatibilityError

Encoding::Converter

Encoding::ConverterNotFoundError

Encoding::InvalidByteSequenceError

Encoding::UndefinedConversionError

EncodingError

Enumerable

Enumerator

Enumerator::Generator

Enumerator::Yielder

Errno

Exception

FalseClass

Fiber

FiberError

File

File::Constants

File::Stat

FileTest

Fixnum

Float

FloatDomainError

GC

GC::Profiler

Hash

IO

IO::WaitReadable

IO::WaitWritable

IOError

IndexError

Integer

Interrupt

Kernel

KeyError

LoadError

LocalJumpError

Marshal

MatchData

Math

Math::DomainError

Method

Module

Mutex

NameError

NameError::message

NilClass

NoMemoryError

NoMethodError

NotImplementedError

Numeric

Object

ObjectSpace

Proc

Process

Process::GID

Process::Status

Process::Sys

Process::UID

Random

Range

RangeError

Rational

Regexp

RegexpError

RubyVM

RubyVM::Env

RubyVM::InstructionSequence

RuntimeError

ScriptError

SecurityError

Signal

SignalException

StandardError

StopIteration

String

Struct

Symbol

SyntaxError

SystemCallError

SystemExit

SystemStackError

Thread

ThreadError

ThreadGroup

Time

TrueClass

TypeError

UnboundMethod

ZeroDivisionError

fatal

=== (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)

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)

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)

alive? (Fiber)

alive? (Thread)

all? (Enumerable)

allocate (Class)

ancestors (Module)

angle (Complex)

angle (Float)

angle (Numeric)

any? (Enumerable)

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)

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

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

include? (Enumerable)

include? (Hash)

include? (Module)

include? (Range)

include? (String)

included_modules (Module)

incomplete_input? (Encoding::InvalidByteSequenceError)

index (Array)

index (String)

infinite? (Float)

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_defined? (Module)

min (Enumerable)

min (Range)

min (Time)

min_by (Enumerable)

minmax (Enumerable)

minmax_by (Enumerable)

mode (File::Stat)

module_eval (Module)

module_exec (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_class_method (Module)

private_instance_methods (Module)

private_method_defined? (Module)

proc (Kernel)

product (Array)

protected_instance_methods (Module)

protected_method_defined? (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)

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 (Numeric)

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)

synchronize (Mutex)

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)

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)