class Array

instance.insert(Integer index, *Elem) -> void

instance.pack(String format) -> String

Array.new() -> instance
Array.new(::Array[Elem] ary) -> instance
Array.new(int size, ?Elem val) -> instance

instance.&(::Array[untyped]) -> ::Array[Elem]

instance.*(string str) -> ::String
instance.*(int int) -> ::Array[Elem]

instance.+[U] (Array[U]) -> ::Array[Elem | U]

instance.-[U] (Array[U]) -> ::Array[Elem]

instance.<<(Elem) -> self

instance.<=>(untyped) -> ::Integer?

instance.==(untyped other) -> bool

instance.[](int index) -> Elem
instance.[](int start, int length) -> ::Array[Elem]?

instance.[]=(int index, Elem obj) -> Elem
instance.[]=(int start, int length, Elem obj) -> Elem
instance.[]=(int start, int length, ::Array[Elem]) -> ::Array[Elem]
instance.[]=(int start, int length, nil) -> nil
instance.[]=(::Range[::Integer?], Elem obj) -> Elem
instance.[]=(::Range[::Integer?], ::Array[Elem]) -> ::Array[Elem]
instance.[]=(::Range[::Integer?], nil) -> nil

instance.all?() -> bool
instance.all?() { (Elem obj) -> boolish } -> bool

instance.at(int index) -> Elem?

instance.clear() -> self

instance.collect!() { (Elem item) -> Elem } -> self

instance.count() -> ::Integer
instance.count(Elem obj) -> ::Integer
instance.count() { (Elem) -> boolish } -> ::Integer

instance.delete_at(int index) -> Elem?

instance.delete_if() { (Elem item) -> boolish } -> self

instance.each() { (Elem item) -> void } -> self

instance.each_index() { (::Integer index) -> void } -> self

instance.empty?() -> bool

instance.find_index(untyped obj) -> ::Integer?
instance.find_index() { (Elem item) -> boolish } -> ::Integer?

instance.first() -> Elem?
instance.first(int n) -> ::Array[Elem]

instance.flatten() -> ::Array[Elem]

instance.include?(Elem object) -> bool

instance.inspect() -> String

instance.join(?string separator) -> String

instance.last() -> Elem?
instance.last(int n) -> ::Array[Elem]

instance.length() -> ::Integer

instance.max() -> Elem?
instance.max() { (Elem a, Elem b) -> ::Integer? } -> Elem?
instance.max(int n) -> ::Array[Elem]
instance.max(int n) { (Elem a, Elem b) -> ::Integer? } -> ::Array[Elem]

instance.pop() -> Elem?
instance.pop(int n) -> ::Array[Elem]

instance.push(*Elem obj) -> self

instance.reject() { (Elem item) -> boolish } -> ::Array[Elem]

instance.reject!() { (Elem item) -> boolish } -> self

instance.shift() -> Elem?
instance.shift(int n) -> ::Array[Elem]

instance.sort() -> ::Array[Elem]
instance.sort() { (Elem a, Elem b) -> ::Integer } -> ::Array[Elem]

instance.sort!() -> self
instance.sort!() { (Elem a, Elem b) -> ::Integer } -> self

instance.unshift(*Elem obj) -> self

instance.|[T] (::Array[T] other_ary) -> ::Array[Elem | T]