diff --git a/core/array.rbs b/core/array.rbs
new file mode 100644
index 0000000..7d4238b
--- /dev/null
+++ b/core/array.rbs
@@ -0,0 +1,133 @@
+class Array[unchecked out Elem] < Object
+  include Enumerable[Elem]
+
+  interface _Pattern[T]
+    def ===: (T other) -> bool
+  end
+
+  def initialize: () -> void
+                | (Integer size, ?Elem val) -> void
+
+  def self.[]: [T](*T item) -> Array[T]
+
+  def +: [T](Array[T] other) -> Array[Elem | T]
+
+  def []: %a{implicitly-returns-nil} (Integer nth) -> Elem
+        | (Range[Integer?] range) -> Array[Elem]?
+        | (Integer start, Integer length) -> Array[Elem]?
+
+  alias at []
+
+  def []=: (Integer nth, Elem val) -> Elem
+         | (Integer start, Integer length, Elem val) -> Elem
+         | (Integer start, Integer length, Array[Elem] val) -> Array[Elem]
+
+  def clear: () -> self
+
+  def difference: (*Array[untyped] other) -> Array[Elem]
+
+  alias - difference
+
+  def delete_at: %a{implicitly-returns-nil} (Integer index) -> Elem
+
+  def empty?: () -> bool
+
+  def size: () -> Integer
+
+  alias length size
+
+  alias count size
+
+  def include?: (Elem val) -> bool
+
+  def &: (Array[untyped] other) -> Array[Elem]
+
+  def |: [T](Array[T] other) -> Array[Elem | T]
+
+  def first: %a{implicitly-returns-nil} () -> Elem
+
+  def last: %a{implicitly-returns-nil} () -> Elem
+
+  def push: (Elem val) -> self
+
+  alias << push
+
+  def pop: () -> Elem?
+         | (Integer n) -> Array[Elem]
+
+  def shift: () -> Elem?
+           | (Integer n) -> Array[Elem]
+
+  def unshift: (Elem val) -> self
+
+  def dup: () -> Array[Elem]
+
+  def min: %a{implicitly-returns-nil} () -> Elem
+
+  def max: %a{implicitly-returns-nil} () -> Elem
+
+  def minmax: () -> [Elem?, Elem?]
+
+  def uniq: () -> Array[Elem]
+
+  def uniq!: () -> self?
+
+  def reverse: () -> Array[Elem]
+
+  def reverse!: () -> self
+
+  def inspect: () -> String
+  def self.inspect: () -> String
+
+  alias to_s inspect
+  alias self.to_s self.inspect
+
+  def join: (?_ToS separator) -> String
+
+  def all?: () -> bool
+          | (_Pattern[Elem] pattern) -> bool
+          | () { (Elem item) -> boolish } -> bool
+
+  def any?: () -> bool
+          | (_Pattern[Elem] pattern) -> bool
+          | () { (Elem item) -> boolish } -> bool
+
+  def collect!: () { (Elem item) -> Elem } -> self
+
+  alias map! collect!
+
+  def delete_if: () { (Elem item) -> boolish } -> self
+
+  def each: () { (Elem item) -> void } -> self
+
+  def each_index: () { (Integer index) -> void } -> self
+
+  def index: (untyped val) -> Integer?
+           | () { (Elem item) -> boolish } -> Integer?
+
+  alias find_index index
+
+  def none?: () -> bool
+           | (_Pattern[Elem] pattern) -> bool
+           | () { (Elem item) -> boolish } -> bool
+
+  def reject!: () { (Elem item) -> boolish } -> self?
+
+  def reject: () { (Elem item) -> boolish } -> Array[Elem]
+
+  def reverse_each: () { (Elem item) -> void } -> self
+
+  def select: () { (Elem item) -> boolish } -> Array[Elem]
+
+  alias filter select
+
+  def select!: () { (Elem item) -> boolish } -> self?
+
+  alias filter! select!
+
+  def sort!: () -> self
+           | () { (Elem a, Elem b) -> Integer } -> self
+
+  def sort: () -> Array[Elem]
+          | () { (Elem a, Elem b) -> Integer } -> Array[Elem]
+end
diff --git a/core/builtin.rbs b/core/builtin.rbs
new file mode 100644
index 0000000..3df4c94
--- /dev/null
+++ b/core/builtin.rbs
@@ -0,0 +1,14 @@
+# rubocop:disable RBS/Lint/TopLevelInterface
+# rubocop:disable RBS/Lint/TopLevelTypeAlias
+
+interface _ToS
+  def to_s: () -> String
+end
+
+interface _Each[out T]
+  def each: () { (T) -> void } -> void
+end
+
+type boolish = top
+
+# rubocop:enable all
diff --git a/core/enumerable.rbs b/core/enumerable.rbs
index 3cdf8d9..00b85bd 100644
--- a/core/enumerable.rbs
+++ b/core/enumerable.rbs
@@ -1,12 +1,7 @@
 module Enumerable[unchecked out Elem] : _Each[Elem]
-  interface _Each[unchecked out T]
-    def each: () { (T) -> void } -> void
-  end
+  def collect: [T]() { (Elem item) -> T } -> Array[T]
 
-  # TODO: Array
-  # def collect: [T]() { (Elem item) -> T } -> Array[T]
-  #
-  # alias map collect
+  alias map collect
 
   def each_with_index: () { (Elem item, Integer index) -> void } -> self
 end
diff --git a/core/object.rbs b/core/object.rbs
index 8f81b7e..6669731 100644
--- a/core/object.rbs
+++ b/core/object.rbs
@@ -39,9 +39,9 @@ class Object < BasicObject
   def nil?: () -> bool
   def self.nil?: () -> bool
 
-  # TODO: Array
   def p: () -> nil
        | [T](T arg0) -> T
+       | [T](*T args) -> Array[T]
 
   def print: (*untyped args) -> nil
 
@@ -65,8 +65,7 @@ class Object < BasicObject
   alias extend include
   alias self.extend self.include
 
-  # TODO: Array
-  # def self.constants: (?bool inherit) -> Array[Symbol]
+  def self.constants: (?bool inherit) -> Array[Symbol]
 
   def self.public: () -> void
 
diff --git a/core/string.rbs b/core/string.rbs
index fe8142d..a57dcbb 100644
--- a/core/string.rbs
+++ b/core/string.rbs
@@ -62,8 +62,7 @@ class String < Object
   def slice!: (Integer nth) -> String?
             | (Integer nth, Integer len) -> String?
 
-  # TODO: Array
-  # def split: (String? sep, ?Integer limit) -> Array[String]
+  def split: (?String? sep, ?Integer limit) -> Array[String]
 
   def lstrip: () -> String
 
@@ -91,8 +90,7 @@ class String < Object
 
   def include?: (String) -> bool
 
-  # TODO: Array
-  # def bytes: () -> Array[Integer]
+  def bytes: () -> Array[Integer]
 
   def upcase: () -> String
 
diff --git a/core/symbol.rbs b/core/symbol.rbs
index 5299ba3..b8d4fb9 100644
--- a/core/symbol.rbs
+++ b/core/symbol.rbs
@@ -1,6 +1,5 @@
 class Symbol < Object
-  # TODO: Array
-  # def self.all_symbols: () -> Array[Symbol]
+  def self.all_symbols: () -> Array[Symbol]
 
   def inspect: () -> String
   def self.inspect: () -> String
diff --git a/test/array.rb b/test/array.rb
new file mode 100644
index 0000000..05347ed
--- /dev/null
+++ b/test/array.rb
@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+# rubocop:disable Lint/Void
+# rubocop:disable Style/EmptyLiteral
+# rubocop:disable Style/RedundantArrayConstructor
+# rubocop:disable Style/NumericPredicate
+# rubocop:disable Style/EvenOdd
+
+arr = [1, 2, 3]
+
+Array.new
+Array.new 10
+Array.new 10, ''
+
+Array[]
+Array[1, 2, 3]
+
+arr + []
+arr + [2]
+arr + ['2']
+
+arr[0]
+arr[0..1]
+arr[0..]
+arr[...2]
+arr[nil...]
+arr[0, 2]
+
+arr.at 0
+arr.at 0..1
+arr.at 0..nil
+arr.at nil...2
+arr.at nil...nil
+arr.at 0, 2
+
+arr[0] = 1
+arr[0, 2] = 1
+arr[0, 2] = [2, 3, 4]
+
+arr.clear
+
+arr.difference []
+arr.difference [], [1], ['a']
+
+arr - []
+arr.-([], [1], ['a'])
+
+arr.delete_at 0
+
+arr.empty?
+
+arr.size
+
+arr.length
+
+arr.count
+
+arr.include? 0
+
+arr & []
+arr & [1, 2]
+arr & [1, 'a', nil]
+
+arr | []
+arr | [4]
+arr | [4, 'a', nil]
+
+arr.first
+
+arr.last
+
+arr.push 1
+
+arr << 1
+
+arr.pop
+arr.pop 2
+
+arr.shift
+arr.shift 2
+
+arr.unshift 1
+
+arr.dup
+
+arr.min
+
+arr.max
+
+arr.minmax
+
+arr.uniq
+
+arr.uniq!
+
+arr.reverse
+
+arr.reverse!
+
+arr.inspect
+Array.inspect
+
+arr.to_s
+Array.to_s
+
+arr.join
+arr.join ','
+arr.join 123
+
+arr.all?
+arr.all? Integer
+arr.all? { |item| item > 0 }
+
+arr.any?
+arr.any? String
+arr.any? { |item| item == 0 }
+
+arr.collect! { |item| item**2 }
+
+arr.map! { |item| item**2 }
+
+arr.delete_if { |item| item % 2 == 0 }
+
+arr.each { |item| item }
+
+arr.each_index { |index| index }
+
+arr.index 1
+arr.index { |item| item > 0 }
+
+arr.find_index 1
+arr.find_index { |item| item > 0 }
+
+arr.none?
+arr.none? String
+arr.none? { |item| item == 0 }
+
+arr.reject! { |item| item == 0 }
+
+arr.reject { |item| item == 0 }
+
+arr.reverse_each { |item| item }
+
+arr.select { |item| item % 2 == 1 }
+
+arr.filter { |item| item % 2 == 1 }
+
+arr.select! { |item| item % 2 == 1 }
+
+arr.filter! { |item| item % 2 == 1 }
+
+arr.sort!
+arr.sort! { |a, b| b - a }
+
+arr.sort
+arr.sort { |a, b| b - a }
+
+# rubocop:enable all
diff --git a/test/enumerable.rb b/test/enumerable.rb
index e1039c0..38f7013 100644
--- a/test/enumerable.rb
+++ b/test/enumerable.rb
@@ -2,6 +2,7 @@
 
 # rubocop:disable Lint/Void
 # rubocop:disable Style/Documentation
+# rubocop:disable Style/SymbolProc
 
 class EnumerableTestClass
   include Enumerable
@@ -14,10 +15,11 @@ def each
 a = EnumerableTestClass.new
 a.each { |item| item }
 
-# TODO: Array
-# a.collect { |item| item }
-#
-# a.map { |item| item }
+a.collect { |item| item }
+a.collect { |item| item.size }
+
+a.map { |item| item }
+a.map { |item| item.size }
 
 a.each_with_index do |item, index|
   item
diff --git a/test/object.rb b/test/object.rb
index 0b6a68c..a996552 100644
--- a/test/object.rb
+++ b/test/object.rb
@@ -64,8 +64,10 @@ module TestMod end
 
 p
 p 1
+p 1, true, 'a'
 object.p
 object.p 1
+object.p 1, true, 'a'
 
 print
 print 1, true, 'a'
@@ -112,6 +114,8 @@ module TestMod end
 Object.extend
 Object.extend TestMod, TestMod, TestMod
 
+Object.constants
+
 sprintf "%d\n", 123
 
 printf "%d\n", 123
diff --git a/test/string.rb b/test/string.rb
index dbfc076..16d3ff5 100644
--- a/test/string.rb
+++ b/test/string.rb
@@ -77,6 +77,11 @@
 'abcdef'.slice! 2
 'abcdef'.slice! 2, 3
 
+'abcdef'.split
+'abcdef'.split nil
+'abcdef'.split 'cd'
+'abcdef'.split 'cd', 1
+
 '  abcdef'.lstrip
 
 '  abcdef'.lstrip!
@@ -103,6 +108,8 @@
 
 'abcdef'.include? 'cd'
 
+'abcdef'.bytes
+
 'abcdef'.upcase
 
 'abcdef'.upcase!
diff --git a/test/symbol.rb b/test/symbol.rb
index a2b4dcf..1c68545 100644
--- a/test/symbol.rb
+++ b/test/symbol.rb
@@ -3,6 +3,8 @@
 # rubocop:disable Lint/SymbolConversion
 # rubocop:disable Lint/RedundantTypeConversion
 
+Symbol.all_symbols
+
 :foo.inspect
 Symbol.inspect