typed.rb 0.0.11

data/spec/lib/typing/tm_send_generic_apply_spec.rb

@@ -0,0 +1,103 @@
+require_relative '../../spec_helper'
+
+describe TypedRb::Model::TmSend do
+  let(:language) { TypedRb::Language.new }
+
+  context 'with a generic type' do
+    it 'creates the correct materialised type' do
+      code = <<__CODE
+        ts 'type Pod1[X<Numeric]'
+        class Pod1
+
+          ts '#initialize / [X] -> unit'
+          def initialize(x)
+             @value = x
+          end
+          ts '#get / -> [X]'
+          def get
+            @value
+          end
+
+          ts '#put / [X] -> unit'
+          def put(x)
+            @value = x
+          end
+
+        end
+
+        Pod1.(Integer)
+__CODE
+
+      result = language.check(code)
+      expect(result.type_vars[0].bound.ruby_type).to eq(Integer)
+    end
+
+    it 'captures type errors in the materialization' do
+
+      code = <<__CODE
+        ts 'type Pod2[X<Numeric]'
+        class Pod2
+
+          ts '#initialize / -> unit'
+          def initialize
+             @value = base
+          end
+
+          ts '#base / -> Float'
+          def base
+            1.0
+          end
+
+          ts '#get / -> [X]'
+          def get
+            @value
+          end
+
+          ts '#put / [X] -> unit'
+          def put(x)
+            @value = x
+          end
+
+        end
+__CODE
+
+      expect {
+        language.check("#{code}; Pod2.(Integer)")
+      }.to raise_error(TypedRb::TypeCheckError)
+
+      result = language.check("#{code}; Pod2.(Float)")
+      expect(result.type_vars[0].bound.ruby_type).to eq(Float)
+    end
+
+    it 'returns the right type information for materialised methods' do
+
+      code = <<__CODE
+        ts 'type Pod3[X<Numeric]'
+        class Pod3
+
+          ts '#initialize / [X] -> unit'
+          def initialize(x)
+             @value = x
+          end
+
+          ts '#get / -> [X]'
+          def get
+            @value
+          end
+
+          ts '#put / [X] -> unit'
+          def put(x)
+            @value = x
+          end
+        end
+__CODE
+
+      expect {
+        language.check("#{code}; p = Pod3.(Integer).new(0.0); p.put(2.0)")
+      }.to raise_error(TypedRb::TypeCheckError)
+
+      result = language.check("#{code}; p = Pod3.(Integer).new(0); p.put(2); p.get")
+      expect(result.ruby_type).to eq(Integer)
+    end
+  end
+end

data/spec/lib/typing/tm_send_generic_methods_spec.rb

@@ -0,0 +1,77 @@
+require_relative '../../spec_helper'
+
+describe TypedRb::Model::TmSend do
+  let(:language) { TypedRb::Language.new }
+
+  it 'applies arguments to generic methods' do
+    code = <<__END
+      ts '#trs / Boolean -> String -> Integer'
+      def trs(a,b); 2; end
+
+      class TestGM1
+        ts '#gm[T][E] / [T] -> &([T] -> [E]) -> [E]'
+        def gm(t)
+          yield t
+        end
+      end
+
+      a = TestGM1.new.gm(true) { |t| false }
+      b = TestGM1.new.gm(1) { |t| 'string' }
+
+      trs(a,b)
+__END
+    result = language.check(code)
+    expect(result.ruby_type).to eq(Integer)
+  end
+
+  it 'applies arguments to generic methods mixing class and method type variables' do
+    code = <<__END
+      ts 'type TestGM2Array[T]'
+      class TestGM2Array
+
+        ts '#initialize / [T] -> unit'
+        def initialize(t)
+         @t = t
+        end
+
+        ts '#map[E] / [T] -> Array[T] -> &([T] -> [E]) -> Array[E]'
+        def map(x, xs)
+          c = Array.('[E]').new
+          c << yield(@t)
+          c
+        end
+      end
+
+      ts '#c / String -> Integer'
+      def c(x)
+        0
+      end
+
+      TestGM2Array.(Integer).new(1).map(1, nil) { |v| v + 1 }
+      TestGM2Array.(String).new('value').map('other', nil) { |v| c(v) }
+__END
+    result = language.check(code)
+    expect(result.ruby_type).to eq(Array)
+    expect(result.type_vars[0].bound.ruby_type).to eq(Integer)
+  end
+
+  it 'type checks the body of generic methods' do
+    code = <<__END
+      class TestGM3
+
+        ts '#test[E] / [E] -> Array[E]'
+        def test(e)
+          es = Array.('[E]').new
+          es << e
+          es
+        end
+      end
+
+      TestGM3.new.test(2)
+      TestGM3.new.test('value')
+__END
+    result = language.check(code)
+    expect(result.ruby_type).to eq(Array)
+    expect(result.type_vars[0].bound.ruby_type).to eq(String)
+  end
+end

data/spec/lib/typing/tm_send_initialize_spec.rb

@@ -0,0 +1,68 @@
+require_relative '../../spec_helper'
+
+describe TypedRb::Model::TmSend do
+
+  before :each do
+    ::BasicObject::TypeRegistry.clear
+  end
+
+  let(:code) do
+    text =<<__CODE
+      class A
+
+        ts '#initialize / Integer -> unit'
+        def initialize(num)
+          'String'
+        end
+
+        ts '#a / -> Integer'
+        def a
+          1
+        end
+
+      end
+
+      a = A.new(3)
+      A.new(a.a)
+__CODE
+    text
+  end
+
+  let(:typed_code) do
+    $TYPECHECK = true
+    eval(code, TOPLEVEL_BINDING)
+    ::BasicObject::TypeRegistry.normalize_types!
+    code
+  end
+
+  let(:ast) do
+    TypedRb::Model::GenSym.reset
+    parser = TypedRb::AstParser.new
+    parser.parse(typed_code)
+  end
+
+  context 'with validly typed code' do
+    it 'type checks a method and method application' do
+      type = ast.check_type(TypedRb::Types::TypingContext.new)
+      expect(type.to_s).to eq("A")
+    end
+  end
+
+  context 'within the class context' do
+    let(:code) do
+      text = <<__CODE
+        class TSICC
+
+         T = new
+        end
+
+        TSICC::T
+__CODE
+    end
+
+    it 'it type checks the initialization correctly' do
+      type = ast.check_type(TypedRb::Types::TypingContext.new)
+      expect(type.to_s).to eq("TSICC")
+    end
+  end
+end

data/spec/lib/typing/tm_send_lambda_spec.rb

@@ -0,0 +1,135 @@
+require_relative '../../spec_helper'
+
+describe TypedRb::Model::TmSend do
+  let(:language) { TypedRb::Language.new }
+
+  context 'with lambda functions' do
+    it 'evaluates lambda functions applications' do
+      expr = <<__END
+     id = ->(x) { x }
+     id[1]
+__END
+
+      result = language.check(expr)
+      expect(result).to eq(tyinteger)
+
+      expr = <<__END
+     id = ->(x) { x }
+     id[1]
+     id['string']
+__END
+
+      result = language.check(expr)
+      expect(result).to eq(tystring)
+    end
+
+    it 'evaluates lambda functions with either types' do
+      expr = <<__END
+      f = ->() do
+          if(true)
+            1.0
+          else
+            return 2
+          end
+      end
+      f[]
+__END
+      result = language.check(expr)
+      expect(result.to_s).to eq('Numeric')
+    end
+
+    it 'evaluates lambda functions with either types including break type' do
+      expr = <<__END
+      f = ->() do
+          if(true)
+            1.0
+          else
+            break 2
+          end
+      end
+      f[]
+__END
+      result = language.check(expr)
+      expect(result).to be_instance_of(TypedRb::Types::TyEither)
+      expect(result[:normal].to_s).to eq('Float')
+      expect(result[:break].to_s).to eq('Jump[break:Integer]')
+    end
+
+    it 'evaluates lambda functions applications with message sending inside' do
+      expr = <<__END
+     class Integer
+       ts '#+ / Integer -> Integer'
+     end
+
+     class String
+       ts '#+ / String -> String'
+     end
+
+     add = ->(x,y) { x + y }
+     add[1,2]
+__END
+
+      result = language.check(expr)
+      expect(result).to eq(tyinteger)
+
+      expr = <<__END
+     class Integer
+       ts '#+ / Integer -> Integer'
+     end
+
+     class String
+       ts '#+ / String -> String'
+     end
+
+     add = ->(x,y) { x + y }
+     add[1,2]
+     add['hello','world']
+__END
+
+      result = language.check(expr)
+      expect(result).to eq(tystring)
+
+      expr = <<__END
+     class Integer
+       ts '#foo / Integer -> String'
+       def foo(x); 'foo'; end
+     end
+
+     f = ->(x,y) { x.foo(y) }
+     f[1,2]
+__END
+
+      result = language.check(expr)
+      expect(result).to eq(tystring)
+
+    end
+
+    it 'catches expcetions in lambda applications' do
+
+      expr = <<__END
+     class Integer
+       ts '#foo / String -> String'
+       def foo(x); 'foo'; end
+     end
+
+     f = ->(x,y) { x.foo(y) }
+     f[1,2]
+__END
+      expect {
+        language.check(expr)
+      }.to raise_error(TypedRb::TypeCheckError)
+
+      expr = <<__END
+     class Integer
+       ts '#foo / String -> String'
+       def foo(x); 'foo'; end
+     end
+
+     f = ->(x,y) { x.foo(y) }
+     f[1,'bar']
+__END
+      result = language.check(expr)
+      expect(result).to eq(tystring)
+    end
+  end
+end

data/spec/lib/typing/tm_send_spec.rb

@@ -0,0 +1,217 @@
+require_relative '../../spec_helper'
+
+#TODO: parsing function will return a symbol, not the function
+# some of this specs expectations need to change
+describe TypedRb::Model::TmSend do
+  let(:language) { TypedRb::Language.new }
+
+  context 'with functions receiving function' do
+    it 'is possible to pass lambda functions as arguments' do
+      expr = <<__END
+      ts '#t / (String -> Integer) -> Integer'
+      def t(f)
+        f['test']
+      end
+
+      f = ->(s) { 0 }
+
+      t(f)
+__END
+
+      result = language.check(expr)
+      expect(result).to eq(tyinteger)
+    end
+
+    it 'detects type check errors in the lambda functions passed as arguments' do
+
+      classes = <<__END
+      class Animal
+        ts '#initialize / -> unit'
+
+        ts '#animal / -> unit'
+        def animal; end
+      end
+
+      class Mammal < Animal
+        ts '#initialize / -> unit'
+
+        ts '#mammal / -> unit'
+        def mammal; end
+      end
+
+      class Cat < Mammal
+        ts '#initialize / -> unit'
+
+        ts '#cat / -> unit'
+        def cat; end
+      end
+__END
+
+      expr = <<__END
+      #{classes}
+
+      ts '#t / (Mammal -> Integer) -> Integer'
+      def t(f)
+        f[Mammal.new]
+      end
+
+      f = ->(s=Mammal.new) { 1.0 }
+
+      t(f)
+__END
+
+      expect {
+        language.check(expr)
+      }.to raise_error(TypedRb::TypeCheckError)
+    end
+
+    it 'respects contravariance in the input type' do
+
+      classes = <<__END
+      class Animal
+        ts '#initialize / -> unit'
+
+        ts '#animal / -> unit'
+        def animal; end
+      end
+
+      class Mammal < Animal
+        ts '#initialize / -> unit'
+
+        ts '#mammal / -> unit'
+        def mammal; end
+      end
+
+      class Cat < Mammal
+        ts '#initialize / -> unit'
+
+        ts '#cat / -> unit'
+        def cat; end
+      end
+__END
+
+      expr = <<__END
+      #{classes}
+
+      ts '#t / (Mammal -> Integer) -> Integer'
+      def t(f)
+        f[Mammal.new]
+      end
+
+      lambda {
+        f = ->(s=Cat.new) { s.cat }
+        t(f)
+      }
+__END
+
+      #expect {
+        language.check(expr)
+        #cat undefined for Mammal,
+        # s => cat s :gt Cat, s :gt Mammal
+      #}.to raise_error(TypedRb::TypeCheckError)
+
+      # TODO: review this?
+      # Actually the previous code does not
+      # throw an error because
+      # Mammal#cat is resolved into
+      # a Dynamic function instead of
+      # failing because no type information
+      # can be found.
+
+      expr = <<__END
+      #{classes}
+
+      ts '#mammal_to_i / (Mammal -> Integer) -> Integer'
+      def mammal_to_i(mammalf)
+        mammalf[Mammal.new]
+      end
+
+      ts '#cat_to_i / (Cat -> Integer) -> Integer'
+      def cat_to_i(catf)
+        mammal_to_i(catf)
+      end
+__END
+      expect {
+        language.check(expr)
+        # Cat not >= Mammal
+      }.to raise_error(TypedRb::TypeCheckError)
+
+      expr = <<__END
+      #{classes}
+
+      ts '#mammal_to_i / (Mammal -> Integer) -> Integer'
+      def mammal_to_i(mammalf)
+        mammalf[Mammal.new]
+      end
+
+      ts '#animal_to_i / (Animal -> Integer) -> Integer'
+      def animal_to_i(animalf)
+        mammal_to_i(animalf)
+      end
+__END
+      result = language.check(expr)
+      expect(result.to_s).to eq('((Animal -> Integer) -> Integer)')
+    end
+
+    it 'respects covariance in the output type' do
+
+      classes = <<__END
+      class Animal
+        ts '#initialize / -> unit'
+
+        ts '#animal / -> unit'
+        def animal; end
+      end
+
+      class Mammal < Animal
+        ts '#initialize / -> unit'
+
+        ts '#mammal / -> unit'
+        def mammal; end
+      end
+
+      class Cat < Mammal
+        ts '#initialize / -> unit'
+
+        ts '#cat / -> unit'
+        def cat; end
+      end
+__END
+
+      expr = <<__END
+      #{classes}
+
+      ts '#integer_to_mammal / (Integer -> Mammal) -> Mammal'
+      def integer_to_mammal(mammalf)
+        mammalf[1]
+      end
+
+      ts '#integer_to_animal / (Integer -> Animal) -> Mammal'
+      def integer_to_animal(animalf)
+        integer_to_mammal(animalf)
+      end
+__END
+      expect do
+        language.check(expr)
+      end.to raise_error(TypedRb::TypeCheckError)
+
+
+      expr = <<__END
+      #{classes}
+
+      ts '#integer_to_mammal / (Integer -> Mammal) -> Mammal'
+      def integer_to_mammal(mammalf)
+        mammalf[1]
+      end
+
+      ts '#integer_to_cat / (Integer -> Cat) -> Mammal'
+      def integer_to_cat(catf)
+        integer_to_mammal(catf)
+      end
+__END
+
+      result  = language.check(expr)
+      expect(result.to_s).to eq('((Integer -> Cat) -> Mammal)')
+    end
+  end
+end