Implement some methods on Literal::Array

lib/literal/array.rb

@@ -46,12 +46,14 @@ def initialize(value, type:)
 		@__type__ = type
 		@__value__ = value
 		@__collection_type__ = collection_type
+		@__generic__ = Literal::Array(type)
 	end
 
 	def __initialize_without_check__(value, type:, collection_type:)
 		@__type__ = type
 		@__value__ = value
 		@__collection_type__ = collection_type
+		@__generic__ = Literal::Array(type)
 		self
 	end
 
@@ -77,6 +79,39 @@ def &(other)
 		end
 	end
 
+	def *(times)
+		case times
+		when String
+			@__value__ * times
+		else
+			__with__(@__value__ * times)
+		end
+	end
+
+	def +(other)
+		case other
+		when ::Array
+			values = @__value__ + @__generic__.new(*other).__value__
+		when Literal::Array
+			values = @__value__ + other.__value__
+		else
+			raise ArgumentError, "Cannot perform `+` with #{other.class.name}."
+		end
+
+		Literal::Array.new(values, type: @__type__)
+	end
+
+	def -(other)
+		case other
+		when ::Array
+			__with__(@__value__ - other)
+		when Literal::Array
+			__with__(@__value__ - other.__value__)
+		else
+			raise ArgumentError.new("Cannot perform `-` with #{other.class.name}.")
+		end
+	end
+
 	def <<(value)
 		Literal.check(actual: value, expected: @__type__) do |c|
 			c.fill_receiver(receiver: self, method: "#<<")
@@ -86,6 +121,17 @@ def <<(value)
 		self
 	end
 
+	def <=>(other)
+		case other
+		when ::Array
+			@__value__ <=> other
+		when Literal::Array
+			@__value__ <=> other.__value__
+		else
+			raise ArgumentError.new("Cannot perform `<=>` with #{other.class.name}.")
+		end
+	end
+
 	def [](index)
 		@__value__[index]
 	end
@@ -112,6 +158,10 @@ def any?(...)
 		@__value__.any?(...)
 	end
 
+	def assoc(...)
+		@__value__.assoc(...)
+	end
+
 	def at(...)
 		@__value__.at(...)
 	end
@@ -125,6 +175,16 @@ def clear(...)
 		self
 	end
 
+	def compact
+		# @TODO if this is an array of nils, we should return an emtpy array
+		__with__(@__value__)
+	end
+
+	def compact!
+		# @TODO if this is an array of nils, we should set @__value__ = [] and return self
+		nil
+	end
+
 	def count(...)
 		@__value__.count(...)
 	end
@@ -199,6 +259,12 @@ def map(type, &block)
 		end
 	end
 
+	def map!(&)
+		new_array = map(@__type__, &)
+		@__value__ = new_array.__value__
+		self
+	end
+
 	def max(n = nil, &)
 		if n
 			__with__(@__value__.max(n, &))

test/array.test.rb

@@ -50,6 +50,18 @@
 	}.to_raise(Literal::TypeError)
 end
 
+test "#map! maps each item correctly" do
+	array = Literal::Array(Integer).new(1, 2, 3)
+
+	expect(array.map!(&:succ).to_a) == [2, 3, 4]
+end
+
+test "map! raises if the type is wrong" do
+	array = Literal::Array(Integer).new(1, 2, 3)
+
+	expect { array.map!(&:to_s) }.to_raise(Literal::TypeError)
+end
+
 test "#[]" do
 	array = Literal::Array(Integer).new(1, 2, 3)
 
@@ -110,6 +122,86 @@
 	expect((array & other).to_a) == [2, 3]
 end
 
+test "#* with an integer multiplies the array" do
+	array = Literal::Array(Integer).new(1, 2, 3)
+
+	result = array * 2
+	assert Literal::Array(Integer) === result
+	expect(result.to_a) == [1, 2, 3, 1, 2, 3]
+end
+
+test "#* raises with a negative integer" do
+	array = Literal::Array(Integer).new(1, 2, 3)
+
+	expect { array * -1 }.to_raise(ArgumentError)
+end
+
+test "#* with a string joins the elements" do
+	array = Literal::Array(Integer).new(1, 2, 3)
+
+	expect(array * ",") == "1,2,3"
+end
+
+test "#+ adds another Literal::Array" do
+	array = Literal::Array(Integer).new(1, 2, 3)
+	other = Literal::Array(Integer).new(4, 5)
+
+	result = array + other
+	assert Literal::Array(Integer) === result
+	expect(result.to_a) == [1, 2, 3, 4, 5]
+end
+
+test "#+ adds an array" do
+	array = Literal::Array(Integer).new(1, 2, 3)
+	other = [4, 5]
+
+	result = array + other
+	assert Literal::Array(Integer) === result
+	expect(result.to_a) == [1, 2, 3, 4, 5]
+end
+
+test "#+ raises if the type is wrong" do
+	array = Literal::Array(Integer).new(1, 2, 3)
+	other = Literal::Array(String).new("a", "b")
+	other_primitive = ["a", "b"]
+
+	expect { array + other }.to_raise(Literal::TypeError)
+	expect { array + other_primitive }.to_raise(Literal::TypeError)
+end
+
+test "#- removes elements from another Literal::Array" do
+	array = Literal::Array(Integer).new(1, 2, 3)
+	other = Literal::Array(Integer).new(1)
+
+	result = array - other
+	expect(result.to_a) == [2, 3]
+end
+
+test "#- removes elements from an array" do
+	array = Literal::Array(Integer).new(1, 2, 3)
+	other = [1]
+
+	result = array - other
+	expect(result.to_a) == [2, 3]
+end
+
+test "#<=> works as expected" do
+	array = Literal::Array(Integer).new(1, 2, 3)
+
+	expect(array <=> [1, 2, 4]) == -1
+	expect(array <=> [1, 2, 2]) == 1
+	expect(array <=> [1, 2, 3, 4]) == -1
+	expect(array <=> [1, 2]) == 1
+	expect(array <=> [1, 2, 3]) == 0
+end
+
+test "#<=> works with another Literal::Array" do
+	array = Literal::Array(Integer).new(1, 2, 3)
+	other = Literal::Array(Integer).new(1, 2, 4)
+
+	expect(array <=> other) == -1
+end
+
 test "#sort sorts the array" do
 	array = Literal::Array(Integer).new(3, 2, 1)
 
@@ -137,6 +229,27 @@
 	expect { array.push(4, "5") }.to_raise(Literal::TypeError)
 end
 
+
+test "#assoc returns the correct element" do
+	array = Literal::Array(Array).new([1, 2], [3, 4])
+
+	expect(array.assoc(1)) == [1, 2]
+	expect(array.assoc(3)) == [3, 4]
+end
+
+test "#compact returns a new Literal::Array" do
+	array = Literal::Array(Integer).new(1, 2, 3)
+
+	expect(array.compact.to_a) == [1, 2, 3]
+	expect(array.compact) != array
+end
+
+test "#compact! returns nil" do
+	array = Literal::Array(Integer).new(1, 2, 3)
+
+	expect(array.compact!) == nil
+end
+
 test "#drop returns a new array with the first n elements removed" do
 		array = Literal::Array(Integer).new(1, 2, 3)
 		dropped = array.drop(1)