Make Array#transpose, Enumerable#reject, Enumerable#to_h work with tuples

spec/std/array_spec.cr

@@ -1830,6 +1830,16 @@ describe "Array" do
       expect_raises(IndexError) { [[1], [1, 2]].transpose }
       expect_raises(IndexError) { [[1, 2], [1]].transpose }
     end
+
+    it "transposes array of tuples" do
+      [{1, 1.0}].transpose.should eq([[1], [1.0]])
+      [{1}, {1.0}].transpose.should eq([[1, 1.0]])
+      [{1, 1.0}, {'a', "aaa"}].transpose.should eq([[1, 'a'], [1.0, "aaa"]])
+
+      typeof([{1, 1.0}].transpose).should eq(Array(Array(Int32 | Float64)))
+      typeof([{1}, {1.0}].transpose).should eq(Array(Array(Int32 | Float64)))
+      typeof([{1, 1.0}, {'a', "aaa"}].transpose).should eq(Array(Array(String | Int32 | Float64 | Char)))
+    end
   end
 
   describe "rotate" do

spec/std/enumerable_spec.cr

@@ -896,6 +896,12 @@ describe "Enumerable" do
       ints.should eq([1, 3])
       ints.should be_a(Array(Int32))
     end
+
+    it "with type, for tuples" do
+      ints = {1, true, false, 3}.reject(Int32)
+      ints.should eq([true, false])
+      ints.should be_a(Array(Bool))
+    end
   end
 
   describe "sample" do
@@ -1132,6 +1138,10 @@ describe "Enumerable" do
       hash = Tuple.new({:a, 1}, {:c, 2}).to_h
       hash.should be_a(Hash(Symbol, Int32))
       hash.should eq({:a => 1, :c => 2})
+
+      hash = Tuple.new({1, 1.0}, {'a', "aaa"}).to_h
+      hash.should be_a(Hash(Int32 | Char, Float64 | String))
+      hash.should eq({1 => 1.0, 'a' => "aaa"})
     end
 
     it "for array" do

src/array.cr

@@ -1263,7 +1263,7 @@ class Array(T)
   end
 
   def self.product(arrays)
-    result = [] of Array(typeof(arrays.first.first))
+    result = [] of Array(typeof(arrays.first_internal.first_internal))
     each_product(arrays) do |product|
       result << product
     end
@@ -1829,16 +1829,16 @@ class Array(T)
   # a           # => [[:a, :b], [:c, :d], [:e, :f]]
   # ```
   def transpose
-    return Array(Array(typeof(first.first))).new if empty?
+    return Array(Array(typeof(first_internal.first_internal))).new if empty?
 
     len = self[0].size
     (1...@size).each do |i|
       l = self[i].size
       raise IndexError.new if len != l
     end
 
-    Array(Array(typeof(first.first))).new(len) do |i|
-      Array(typeof(first.first)).new(@size) do |j|
+    Array(Array(typeof(first_internal.first_internal))).new(len) do |i|
+      Array(typeof(first_internal.first_internal)).new(@size) do |j|
         self[j][i]
       end
     end

src/enumerable.cr

@@ -222,7 +222,7 @@ module Enumerable(T)
   # ["Alice", "Bob"].compact_map { |name| name.match(/^A./) } # => [Regex::MatchData("Al")]
   # ```
   def compact_map
-    ary = [] of typeof((yield first).not_nil!)
+    ary = [] of typeof((yield first_internal).not_nil!)
     each do |e|
       v = yield e
       unless v.is_a?(Nil)
@@ -525,7 +525,7 @@ module Enumerable(T)
   # array # => ['A', 'l', 'i', 'c', 'e', 'B', 'o', 'b']
   # ```
   def flat_map(&block : T -> _)
-    ary = [] of typeof(flat_map_type(yield first))
+    ary = [] of typeof(flat_map_type(yield first_internal))
     each do |e|
       case v = yield e
       when Array, Iterator
@@ -1233,7 +1233,7 @@ module Enumerable(T)
   # ```
   def reject(type : U.class) forall U
     ary = [] of typeof(begin
-      e = first
+      e = first_internal
       e.is_a?(U) ? raise("") : e
     end)
     each { |e| ary << e unless e.is_a?(U) }
@@ -1480,7 +1480,7 @@ module Enumerable(T)
   # ([] of Int32).sum { |x| x + 1 } # => 0
   # ```
   def sum(&block)
-    sum(additive_identity(Reflect(typeof(yield first)))) do |value|
+    sum(additive_identity(Reflect(typeof(yield first_internal)))) do |value|
       yield value
     end
   end
@@ -1559,7 +1559,7 @@ module Enumerable(T)
   # ([] of Int32).product { |x| x + 1 } # => 1
   # ```
   def product(&block)
-    product(Reflect(typeof(yield first)).first.multiplicative_identity) do |value|
+    product(Reflect(typeof(yield first_internal)).first.multiplicative_identity) do |value|
       yield value
     end
   end
@@ -1650,7 +1650,7 @@ module Enumerable(T)
   # Tuple.new({:a, 1}, {:c, 2}).to_h # => {:a => 1, :c => 2}
   # ```
   def to_h
-    each_with_object(Hash(typeof(first[0]), typeof(first[1])).new) do |item, hash|
+    each_with_object(Hash(typeof(first_internal[0]), typeof(first_internal[1])).new) do |item, hash|
       hash[item[0]] = item[1]
     end
   end
@@ -1911,4 +1911,10 @@ module Enumerable(T)
       {% end %}
     end
   end
+
+  # :nodoc:
+  def first_internal
+    # overridden in Tuple to disable literal index lookup
+    first
+  end
 end

src/tuple.cr

@@ -587,4 +587,10 @@ struct Tuple
       self[{{T.size - 1}}]
     {% end %}
   end
+
+  # :nodoc:
+  def first_internal
+    i = 0
+    self[i]
+  end
 end