typed.rb 0.0.11

data/spec/lib/prelude/array_spec.rb

@@ -0,0 +1,263 @@
+require_relative '../../spec_helper'
+
+describe Array do
+  let(:language) { TypedRb::Language.new }
+
+  describe '#initialize' do
+    it 'type checks / -> Array[T]' do
+      result = language.check('Array.(Integer).new')
+      expect(result.ruby_type).to eq(Array)
+      expect(result.type_vars.first.bound.ruby_type).to eq(Integer)
+    end
+
+    it 'type checks / Integer -> Array[T]' do
+      result = language.check('Array.(Integer).new(3)')
+      expect(result.ruby_type).to eq(Array)
+      expect(result.type_vars.first.bound.ruby_type).to eq(Integer)
+    end
+
+    it 'type checks / Integer -> [T] -> Array[T]' do
+      result = language.check('Array.(String).new(3, "start")')
+      expect(result.ruby_type).to eq(Array)
+      expect(result.type_vars.first.bound.ruby_type).to eq(String)
+
+      expect {
+        result = language.check('Array.(String).new(3, 0)')
+      }.to raise_error(TypedRb::Types::UncomparableTypes)
+    end
+  end
+
+  describe '#[]' do
+    it 'type checks / Object -> Object' do
+      result = language.check('Array.(Integer).new(10,0)[0]')
+      expect(result.ruby_type).to eq(Object)
+    end
+
+    it 'type checks / Integer -> Integer - Array[T]' do
+      result = language.check('Array.(Integer).new(10,0)[0, 3]')
+      expect(result.ruby_type).to eq(Array)
+      expect(result.type_vars.first.bound.ruby_type).to eq(Integer)
+    end
+  end
+
+  describe '#collect[E]' do
+    it 'type checks / &([T] -> [E]) -> Array[E]' do
+      result = language.check('Array.(Integer).new(10,0).collect{ |e| e.to_s }')
+      expect(result.ruby_type).to eq(Array)
+      expect(result.type_vars.first.bound.ruby_type).to eq(String)
+    end
+  end
+
+  describe '#concat' do
+    it 'type checks / Array[T] -> Array[T]' do
+      result = language.check('Array.(Integer).new(10,0).concat(Array.(Integer).new(10,0))')
+      expect(result.ruby_type).to eq(Array)
+      expect(result.type_vars.first.bound.ruby_type).to eq(Integer)
+
+      expect {
+        language.check('Array.(Integer).new(10,0).concat(Array.(String).new(10,"blah"))')
+      }.to raise_error(TypedRb::Types::UncomparableTypes)
+    end
+  end
+
+  describe '#count' do
+    it 'type checks / &([T] -> Boolean) -> Integer' do
+      result = language.check('Array.(Integer).new(10,0).count(0)')
+      expect(result.ruby_type).to eq(Integer)
+
+      result = language.check('Array.(Integer).new(10,0).count{ |x| x == 0 }')
+      expect(result.ruby_type).to eq(Integer)
+
+      expect {
+        code = <<__CODE
+          ts '#testarrs / String -> Boolean'
+          def testarrs(s); true; end
+
+          Array.(Integer).new(10,0).count{ |x| testarrs(x) }
+__CODE
+        language.check(code)
+      }.to raise_error(TypedRb::Types::UncomparableTypes)
+    end
+  end
+
+  describe '#eql?' do
+    it 'type checks / Array[?] -> Boolean' do
+      code = <<__CODE
+        as = Array.(Integer).new(10,0)
+        bs = Array.(String).new(10,'')
+
+        as.eql?(bs)
+__CODE
+      result = language.check(code)
+      expect(result.ruby_type).to eq(TrueClass)
+    end
+  end
+
+  describe '#flatten' do
+    it 'type checks / -> Array[Object]' do
+      code =  <<__END
+         a1 =  Array.(Integer).new.fill(10,0)
+         a2 = Array.(Integer).new.fill(10,1)
+         c = Array.('Array[Integer]').new
+         c << a1
+         c << a2
+         c.flatten
+__END
+      result = language.check(code)
+      expect(result.ruby_type).to eq(Array)
+      expect(result.type_vars.first.bound.ruby_type).to eq(Object)
+    end
+
+    it 'type checks / Integer -> Array[Object]' do
+      code =  <<__END
+         a1 =  Array.(Integer).new.fill(10,0)
+         a2 = Array.(Integer).new.fill(10,1)
+         c = Array.('Array[Integer]').new
+         c << a1
+         c << a2
+         c.flatten(2)
+__END
+      result = language.check(code)
+      expect(result.ruby_type).to eq(Array)
+      expect(result.type_vars.first.bound.ruby_type).to eq(Object)
+    end
+  end
+
+  describe '#include?' do
+    it 'type checks / [T] -> Boolean' do
+      code = <<__END
+         a = Array.(Integer).new.fill(10,0)
+
+         a.include?(1)
+__END
+      result = language.check(code)
+      expect(result.ruby_type).to eq(TrueClass)
+
+      code = <<__END
+         a = Array.(Integer).new.fill(10,0)
+
+         a.include?('a')
+__END
+      expect {
+        language.check(code)
+      }.to raise_error(TypedRb::Types::UncomparableTypes)
+    end
+  end
+
+  describe '#insert' do
+    it 'type checks / Integer -> [T] -> Array[T]' do
+      code = <<__END
+         a = Array.(Integer).new.fill(10,0)
+
+         a.insert(0, 1)
+
+         a.insert(0, 1, 2, 3)
+__END
+
+      result = language.check(code)
+      expect(result.ruby_type).to eq(Array)
+      expect(result.type_vars.first.bound.ruby_type).to eq(Integer)
+    end
+  end
+
+  describe '#last' do
+    it 'type checks / -> [T]' do
+      code = <<__END
+        a = Array.(Integer).new.fill(10,0)
+        a.last
+__END
+      result = language.check(code)
+      expect(result.ruby_type).to eq(Integer)
+    end
+
+    it 'type checks / Integer -> Array[T]' do
+      code = <<__END
+        a = Array.(Integer).new.fill(10,0)
+        a.last(5)
+__END
+      result = language.check(code)
+      expect(result.ruby_type).to eq(Array)
+      expect(result.type_vars.first.bound.ruby_type).to eq(Integer)
+    end
+  end
+
+  describe '#map[E]' do
+    it 'type checks / &([T] -> [E]) -> Array[E]' do
+      result = language.check('Array.(Integer).new(10,0).map{ |e| e.to_s }')
+      expect(result.ruby_type).to eq(Array)
+      expect(result.type_vars.first.bound.ruby_type).to eq(String)
+    end
+  end
+
+  describe '#permutation' do
+    it 'type checks / -> Array[Array[T]]' do
+      result = language.check('Array.(Integer).new(10,0).permutation')
+      expect(result.ruby_type).to eq(Array)
+      expect(result.type_vars.first.bound.ruby_type).to eq(Array)
+      expect(result.type_vars.first.bound.type_vars.first.bound.ruby_type).to eq(Integer)
+    end
+  end
+
+  describe '#product' do
+    it 'type checks / Array[T]... -> Array[Array[T]]' do
+      result = language.check('Array.(Integer).new(10,0).product(Array.(Integer).new(5,1), Array.(Integer).new(5,2))')
+      expect(result.ruby_type).to eq(Array)
+      expect(result.type_vars.first.bound.ruby_type).to eq(Array)
+      expect(result.type_vars.first.bound.type_vars.first.bound.ruby_type).to eq(Integer)
+    end
+  end
+
+  describe '#push' do
+
+    it 'type checks / [T]... -> Array[T]' do
+      result = language.check('Array.(Integer).new.push(1,2,3)')
+      expect(result.ruby_type).to eq(Array)
+      expect(result.type_vars.first.bound.ruby_type).to eq(Integer)
+
+      expect {
+        language.check('Array.(Integer).new.push(1,2.0,3)')
+      }.to raise_error(TypedRb::Types::UncomparableTypes)
+    end
+  end
+
+  describe '#sort' do
+    it 'type checks / &([T] -> [T] -> Integer) -> Array[T]' do
+      code = <<__END
+        a = Array.(Integer).new.fill(10,0)
+        a.sort
+__END
+      result = language.check(code)
+      expect(result.ruby_type).to eq(Array)
+      expect(result.type_vars.first.bound.ruby_type).to eq(Integer)
+
+      code = <<__END
+        a = Array.(Integer).new.fill(10,0)
+        ts '#tcii / Integer -> Integer -> Integer'
+        def tcii(a,b); a <=> b; end
+        a.sort{ |a,b| tcii(a,b) }
+__END
+      result = language.check(code)
+      expect(result.ruby_type).to eq(Array)
+      expect(result.type_vars.first.bound.ruby_type).to eq(Integer)
+
+      code = <<__END
+        ts '#tcss / String -> String -> Integer'
+        def tcss(a,b); -1; end
+        a = Array.(Integer).new.fill(10,0)
+        a.sort{ |a,b| tcss(a,b) }
+__END
+
+      expect {
+        language.check(code)
+      }.to raise_error(TypedRb::Types::UncomparableTypes)
+    end
+  end
+
+  describe '#to_s' do
+    it 'type checks / -> Hash[T][T]' do
+      result = language.check('Array.(Integer).new.to_h')
+      expect(result.ruby_type).to eq(Hash)
+      expect(result.type_vars.map(&:bound).map(&:ruby_type)).to eq([Integer, Integer])
+    end
+  end
+end

data/spec/lib/prelude/class_spec.rb

@@ -0,0 +1,12 @@
+require_relative '../../spec_helper'
+
+describe Class do
+  let(:language) { TypedRb::Language.new }
+
+  describe '#initialize' do
+    it 'type checks / Class -> Class' do
+      result = language.check('Class.new(Object)')
+      expect(result.ruby_type).to eq(Class)
+    end
+  end
+end

data/spec/lib/prelude/enumerable_spec.rb

@@ -0,0 +1,278 @@
+require_relative '../../spec_helper'
+
+describe Enumerable do
+  let(:language) { TypedRb::Language.new }
+
+  describe '#all?' do
+    context 'for Array' do
+      it 'type checks / &([T] -> Boolean) -> Boolean' do
+        code = <<__CODE
+       ts '#int_fn / Integer -> Boolean'
+       def int_fn(e); true; end
+       Array.(Integer).new.all? { |e| int_fn(e) }
+__CODE
+        result = language.check(code)
+
+        expect(result.to_s).to eq('Boolean')
+
+        expect {
+          code = <<__CODE
+       ts '#str_fn / String -> Boolean'
+       def str_fn(e); true; end
+       Array.(Integer).new.all? { |e| str_fn(e) }
+__CODE
+          language.check(code)
+        }.to raise_error(TypedRb::Types::UncomparableTypes)
+      end
+    end
+
+    context 'for Hash' do
+      it 'type checks / &([T] -> Boolean) -> Boolean' do
+        code = <<__CODE
+       ts '#str_int_fn / String -> Integer -> Boolean'
+       def str_int_fn(s,i); true; end
+       Hash.(String,Integer).new.all? { |k,v| str_int_fn(k,v) }
+__CODE
+        result = language.check(code)
+
+        expect(result.to_s).to eq('Boolean')
+
+        code = <<__CODE
+       ts '#str_int_fn / String -> Integer -> Boolean'
+       def str_int_fn(s,i); true; end
+       Hash.(String,Integer).new.all? { |p| str_int_fn(p.first,p.second) }
+__CODE
+        result = language.check(code)
+
+        expect(result.to_s).to eq('Boolean')
+
+        expect {
+          code = <<__CODE
+       ts '#str_str_fn / String -> String -> Boolean'
+       def str_str_fn(s,i); true; end
+       Hash.(String,Integer).new.all? { |k,v| str_str_fn(k,v) }
+__CODE
+          language.check(code)
+        }.to raise_error(TypedRb::Types::UncomparableTypes)
+
+        expect {
+          code = <<__CODE
+       ts '#str_str_fn / String -> String -> Boolean'
+       def str_str_fn(s,i); true; end
+       Hash.(String,Integer).new.all? { |p| str_str_fn(p.first,p.second) }
+__CODE
+          language.check(code)
+        }.to raise_error(TypedRb::Types::UncomparableTypes)
+      end
+    end
+  end
+
+  describe '#chunk' do
+    describe '&([T] -> Boolean) -> Enumerator[Pair[Boolean][Array[T]]]' do
+      it 'type checks it correctly, positive case' do
+        code = <<__CODE
+           ts "#int_bool_fn / Integer -> Boolean"
+           def int_bool_fn(i); true; end
+
+           ts '#bool_int_ary_fn / Boolean -> Array[Integer] -> unit'
+           def bool_int_ary_fn(b,a); nil; end
+
+           [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5].chunk { |n|
+              int_bool_fn(n)
+           }.each { |even, ary|
+              bool_int_ary_fn(even, ary)
+           }
+__CODE
+        result = language.check(code)
+
+        expect(result.to_s).to eq('Object')
+      end
+
+      it 'type checks it correctly, negative case 1' do
+        code = <<__CODE
+           ts "#float_bool_fn / Float -> Boolean"
+           def float_bool_fn(f); true; end
+
+           [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5].chunk { |n|
+              float_bool_fn(n)
+           }
+__CODE
+
+        expect {
+          language.check(code)
+        }.to raise_error(TypedRb::Types::UncomparableTypes)
+      end
+
+      it 'type checks it correctly, negative case 2' do
+        code = <<__CODE
+           ts "#int_bool_fn / Integer -> Boolean"
+           def int_bool_fn(i); true; end
+
+           ts "#int_fn / Integer -> unit"
+           def int_fn(i); nil; end
+
+           [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5].chunk { |n|
+              int_bool_fn(n)
+           }.each { |b,i|
+              int_fn(i)
+           }
+__CODE
+
+        expect {
+          language.check(code)
+        }.to raise_error(TypedRb::Types::UncomparableTypes)
+      end
+    end
+  end
+
+  describe '#detect' do
+    describe '&([T] -> Boolean) -> [T]' do
+      it 'type checks it correctly, positive case' do
+        code = <<__CODE
+           ts "#int_bool_fn / Integer -> Boolean"
+           def int_bool_fn(i); true; end
+
+           [1, 2, 3, 4].detect{ |i| int_bool_fn(i) }
+__CODE
+        result = language.check(code)
+
+        expect(result.to_s).to eq('Integer')
+      end
+
+      it 'type checks it correctly, negative case' do
+        code = <<__CODE
+           ts "#float_bool_fn / Float -> Boolean"
+           def float_bool_fn(f); true; end
+
+           [1, 2, 3, 4].detect { |i| float_bool_fn(i) }
+__CODE
+        expect {
+          language.check(code)
+        }.to raise_error(TypedRb::Types::UncomparableTypes)
+      end
+    end
+
+    describe '[T] -> Enumerator[T]' do
+      it 'type checks it correctly, positive case' do
+        code = <<__CODE
+           [1, 2, 3, 4].detect
+__CODE
+        result = language.check(code)
+
+        expect(result.to_s).to eq('Enumerator[Integer]')
+      end
+    end
+  end
+
+  describe '#each_cons' do
+    describe 'Integer -> Enumerator[Array[T]]' do
+      it 'type checks it correctly, positive case' do
+        code = <<__CODE
+       [1,2,3].each_cons(2)
+__CODE
+        result = language.check(code)
+
+        expect(result.to_s).to eq('Enumerator[Array[Integer]]')
+      end
+
+      it 'type checks it correctly, positive case' do
+        code = <<__CODE
+       [1,2,3].each_cons(2).first
+__CODE
+        result = language.check(code)
+
+        expect(result.to_s).to eq('Array[Integer]')
+      end
+    end
+  end
+
+  describe '#grep' do
+    describe 'Regexp -> Array[T]' do
+      it 'type checks it correctly' do
+        result = language.check('["1","2","3","e","f","4"].grep(/\d/)')
+        expect(result.to_s).to eq('Array[String]')
+      end
+    end
+
+    describe '[E] / Regexp -> &([T] -> [E]) -> Array[E]' do
+      it 'type checks it correctly, positive case' do
+        code = <<__CODE
+        ts '#s_to_i / String -> Integer'
+        def s_to_i(s); 0; end
+
+        ["1","2","3","e","f","4"].grep(/\d/){ |e| s_to_i(e) }
+__CODE
+        result = language.check(code)
+        expect(result.to_s).to eq('Array[Integer]')
+      end
+
+      it 'type checks it correctly, negative case' do
+        code = <<__CODE
+        ts '#f_to_i / Float -> Integer'
+        def f_to_i(s); 0; end
+
+        ["1","2","3","e","f","4"].grep(/\d/){ |e| f_to_i(e) }
+__CODE
+        expect {
+          language.check(code)
+        }.to raise_error(TypedRb::Types::UncomparableTypes)
+      end
+    end
+  end
+
+  describe '#max' do
+    describe '&(Pair[T][T] -> Integer) -> [T]' do
+      it 'type checks it correctly, positive case' do
+        code = <<__CODE
+          ts '#int_int_fn / Integer -> Integer -> Integer'
+          def int_int_fn(a,b); a+b; end
+
+          [1,2,3,4,5].max { |a,b| int_int_fn(a,b) }
+__CODE
+        result = language.check(code)
+        expect(result.to_s).to eq('Integer')
+      end
+    end
+  end
+
+  describe '#partition' do
+    describe '&([T] -> Boolean) -> Pair[Array[T]][Array[T]]' do
+      it 'type checks it correclty, positive case' do
+        code = <<__CODE
+           ts '#odd? / Integer -> Boolean'
+           def odd?(e); false; end
+
+           [1,2,3,4,5,6].partition { |e| odd?(e) }
+__CODE
+        result = language.check(code)
+        expect(result.to_s).to eq('Pair[Array[Integer]][Array[Integer]]')
+      end
+    end
+  end
+
+  describe '#sort_by' do
+    describe '[Comparable[E]] / &([T] -> [E]) -> Array[T]' do
+      it 'type checks it correctly, positive case' do
+        code = <<__CODE
+        ["apple", "pear", "fig" ].sort_by {|word| word.length }
+__CODE
+
+        result = language.check(code)
+        expect(result.to_s).to eq('Array[String]')
+      end
+
+      it 'type checks it correctly, negative case' do
+        code = <<__CODE
+        ts '#uncomparable / String -> Object'
+        def uncomparable(s); Object.new; end
+
+        ->(){ ["apple", "pear", "fig" ].sort_by {|word| uncomparable(word) } }
+__CODE
+
+        expect {
+          language.check(code)
+        }.to raise_error(TypedRb::Types::UncomparableTypes)
+      end
+    end
+  end
+end

data/spec/lib/prelude/enumerator_spec.rb

@@ -0,0 +1,101 @@
+require_relative '../../spec_helper'
+
+describe Enumerator do
+  let(:language) { TypedRb::Language.new }
+
+  describe '#initialize' do
+    it 'type checks / Integer -> Enumerator[T]' do
+      result = language.check('Enumerator.(Integer).new(10)')
+      expect(result.to_s).to eq('Enumerator[Integer]')
+    end
+
+    it 'type checks / &(Enumerator::Yielder[T] -> unit) -> Enumerator[T]' do
+      result = language.check('Enumerator.(Integer).new { |y| y.yield(10) }')
+      expect(result.to_s).to eq('Enumerator[Integer]')
+
+      expect {
+        language.check('Enumerator.(Integer).new { |y| y.yield("string") }')
+      }.to raise_error(TypedRb::Types::UncomparableTypes)
+    end
+
+    it 'type checks / Object -> Symbol -> Enumerator[T]' do
+      result = language.check('Enumerator.(String).new Object.new')
+      expect(result.to_s).to eq('Enumerator[String]')
+    end
+  end
+
+  describe '#each' do
+    it 'type checks / -> Enumerator[T]' do
+      result = language.check('Enumerator.(Integer).new { |y| y.yield(10) }.each')
+      expect(result.to_s).to eq('Enumerator[Integer]')
+    end
+
+    it 'type checks / &([T] -> unit) -> Object' do
+      code = <<__CODE
+       Enumerator.(Integer).new { |y| y.yield(10) }.each do |i|
+         i + 1
+       end
+__CODE
+      result = language.check(code)
+      expect(result.to_s).to eq('Object')
+
+      code = <<__CODE
+       ts '#str_fn / String -> unit'
+       def str_fn(s); end
+
+       Enumerator.(Integer).new { |y| y.yield(10) }.each do |i|
+         str_fn(i)
+       end
+__CODE
+      expect {
+        language.check(code)
+      }.to raise_error(TypedRb::Types::UncomparableTypes)
+    end
+  end
+
+  describe '#each_with_index' do
+    it 'type checks / -> Enumerator[Pair[T][Integer]]' do
+      result = language.check('Enumerator.(Integer).new { |y| y.yield(10) }.each_with_index')
+
+      expect(result.to_s).to eq('Enumerator[Pair[Integer][Integer]]')
+    end
+
+    it 'type checks / -> Enumerator[Pair[T][Integer]] multiple invocations' do
+      result = language.check('Enumerator.(Integer).new { |y| y.yield(10) }.each_with_index.each_with_index')
+      expect(result.to_s).to eq('Enumerator[Pair[Pair[Integer][Integer]][Integer]]')
+    end
+
+    it 'type checks / &([T] -> Integer -> unit) -> Object' do
+      code = <<__CODE
+       ts '#int_int_fn / Integer -> Integer -> Integer'
+       def int_int_fn(x,y); x + y; end
+       Enumerator.(Integer).new { |y| y.yield(10) }.each_with_index do |e, i|
+          int_int_fn(e,i)
+       end
+__CODE
+
+      result = language.check(code)
+      expect(result.to_s).to eq('Object')
+
+      expect {
+        code = <<__CODE
+       ts '#int_int_fn / Integer -> Integer -> Integer'
+       def int_int_fn(x,y); y; end
+       Enumerator.(String).new { |y| y.yield("str") }.each_with_index do |e, i|
+          int_int_fn(e,i)
+       end
+__CODE
+
+        result = language.check(code)
+      }.to raise_error(TypedRb::Types::UncomparableTypes)
+    end
+  end
+
+  describe '#each_with_object' do
+    it 'type checks[E] / -> Enumerator[Pair[T][E]]' do
+      result = language.check('Enumerator.(Integer).new { |y| y.yield(10) }.each_with_object("String")')
+
+      expect(result.to_s).to eq('Enumerator[Pair[Integer][String]]')
+    end
+  end
+end