feat: Array を定義 (#46)

* chore: util インターフェースを buildin.rbs に移動

* feat: `Array` を定義

* chore: テストを追加

* chore: 不要な unchecked を削除

* feat: mrblib から提供される `Array` のメソッドを定義

* chore: テストを追加

* feat: `Enumerable` の `TODO: Array` に対応

* feat: `Object` の `TODO: Array` に対応

* feat: `Symbol` の `TODO: Array` に対応

* feat: `String` の `TODO: Array` に対応

* chore: Rubocop のルールを調整

Author: tufusa

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

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

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

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
 

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
 

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

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

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