typed.rb 0.0.19 → 0.0.20

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 275c43f2dc819f16b312b04476aeb6e2348b901c
-  data.tar.gz: a3bee9cfa379440d26e4ed53d65bda969deeaa8c
+  metadata.gz: 3e1e422526418b9f47944538620729fa863861a4
+  data.tar.gz: bf8d5cd5f765212d7a28c4da99fbc5b7d76a5e6c
 SHA512:
-  metadata.gz: d56e1eb679fc7443cb0f85da729c1680236cea4f6bf25e6eed316cb54ed5a1b5783cebc121ce5b34843060a1f97570f6f9f82eb42e9ab8c2712591fc6d6ae3d6
-  data.tar.gz: d3de0f7e334161c2e99e700efe52d0492e57b464d612413c5c86f069114e9393c94d2b8356270a509de8efb69471df627d7df879ce71f1eef9f6810fb19cdc25
+  metadata.gz: 1e1dc72ba7ff3932c5809e598667c2845235ae866364b84db98659bf1680f9701098d95db748055378aecd91f2ee20b3d6085c719aa0430c26c84180033639e2
+  data.tar.gz: b66faa42ec89f9f7bafac169ef736b55bde2156b2c977a24052d35707f6fb0403a10fdfe9f1f697d22ffbf2b7990b773ed1a805811dcdbc34492873018addef5

data/lib/typed/model/tm_module.rb

@@ -27,7 +27,9 @@ module TypedRb
         unification = Types::Polymorphism::Unification.new(module_type.local_typing_context.all_constraints,
                                                            :allow_unbound_receivers => true)
         unification.run
-
+        if(module_type.is_a?(TypedRb::Types::TyGenericExistentialType))
+          module_type.clean_dynamic_bindings
+        end
         module_type
       end
 
@@ -38,6 +40,21 @@ module TypedRb
         module_self_variable.node = node
         module_self_variable.module_type = module_type
         module_type.self_variable = module_self_variable
+
+        if(module_type.is_a?(TypedRb::Types::TyGenericExistentialType))
+          module_type.type_vars.each do |type_var|
+            type_var = Types::TypingContext.type_variable_for_generic_type(type_var)
+            type_var.node = node
+
+            if type_var.upper_bound
+              type_var.compatible?(type_var.upper_bound, :lt)
+            end
+
+            if type_var.lower_bound
+              type_var.compatible?(type_var.lower_bound, :gt)
+            end
+          end
+        end
         yield(module_self_variable)
 
         # Since every single time we find the generic type the same instance

data/lib/typed/model/tm_send.rb

@@ -125,8 +125,9 @@ module TypedRb
             type_var_signature = argument.node.children.first
             maybe_generic_method_var = Types::TypingContext.vars_info(:method)[type_var_signature]
             maybe_generic_class_var = Types::TypingContext.vars_info(:class)[type_var_signature]
-            if maybe_generic_method_var || maybe_generic_class_var
-              maybe_generic_method_var || maybe_generic_class_var
+            maybe_generic_module_var = Types::TypingContext.vars_info(:module)[type_var_signature]
+            if maybe_generic_method_var || maybe_generic_class_var || maybe_generic_module_var
+              maybe_generic_method_var || maybe_generic_class_var || maybe_generic_module_var
             else
               parsed_types = TypeSignature::Parser.parse(type_var_signature)
               if parsed_types.is_a?(Array)
@@ -236,7 +237,8 @@ module TypedRb
                                         rest_type
                                       end
               actual_arguments[index..-1].each do |actual_argument|
-                unless actual_argument.check_type(context).compatible?(formal_parameter_type, :lt)
+                actual_argument_type = actual_argument.check_type(context)
+                unless actual_argument_type.compatible?(formal_parameter_type, :lt)
                   error_message = "Error type checking message sent '#{message}': #{formal_parameter_type} expected, #{actual_argument_type} found"
                   fail TypeCheckError.new(error_message, node)
                 end

data/lib/typed/types/polymorphism/generic_object.rb

@@ -63,8 +63,11 @@ module TypedRb
           end
 
           generic_function = (from_args + [to_arg, materialized_block_type]).any? do |arg|
-            arg.is_a?(Polymorphism::TypeVariable) ||
-                (arg.respond_to?(:generic?) && arg.generic?)
+            next arg.bound.nil? if arg.is_a?(Polymorphism::TypeVariable)
+            next false if !arg.respond_to?(:generic?) || !arg.generic?
+            next true if arg.is_a?(Types::TyGenericFunction)
+            unbound_vars = arg.unbound_vars
+            unbound_vars.count > 0
           end
 
           if generic_function

data/lib/typed/types/polymorphism/generic_variables.rb

@@ -18,6 +18,18 @@ module TypedRb
           #  acc[type_var.variable] = type_var
           #end.values
         end
+
+        def unbound_vars
+          @type_vars.map do |type_var|
+            if type_var.is_a?(Polymorphism::TypeVariable) && type_var.bound_to_generic?
+              type_var.bound.unbound_vars
+            elsif type_var.is_a?(Polymorphism::TypeVariable)
+              type_var if type_var.bound.nil?
+            else
+              type_var.unbound_vars
+            end
+          end.flatten.reject(&:nil?)
+        end
       end
     end
   end

data/lib/typed/types/polymorphism/type_variable.rb

@@ -115,6 +115,19 @@ module TypedRb
         def bound_to_generic?
           bound && bound.respond_to?(:generic?) && bound.generic?
         end
+
+        def clean_dynamic_bindings
+          if @bound.is_a?(TypedRb::Types::TyDynamic)
+            @bound = nil
+          end
+          if @lower_bound.is_a?(TypedRb::Types::TyDynamic)
+            @lower_bound = nil
+          end
+          if @upper_bound.is_a?(TypedRb::Types::TyDynamic)
+            @upper_bound = nil
+          end
+        end
+
       end
     end
   end

data/lib/typed/types/polymorphism/type_variable_register.rb

@@ -166,7 +166,7 @@ module TypedRb
           else
             key = [:local, nil, variable_name]
             type_variables_register[key] = TypeVariable.new(variable_name, gen_name: false)
-            @constraints[variable_name] = [relation_type, type]
+            @constraints[variable_name] = [[relation_type, type]]
             # fail StandardError, "Cannot find variable #{variable_name} to add a constraint"
           end
         end
@@ -200,6 +200,23 @@ module TypedRb
           [apply_type(parent, substitutions), substitutions]
         end
 
+        def clean_dynamic_bindings
+          constraints.values.each do |constraint|
+            constraint.each do |type, value|
+              if type == :lt || type == :gt
+                if value.is_a?(TypedRb::Types::Polymorphism::TypeVariable)
+                  value.clean_dynamic_bindings
+                end
+              end
+            end
+          end
+          type_variables_register.values.each do |type_var|
+            if type_var.is_a?(TypedRb::Types::Polymorphism::TypeVariable)
+              type_var.clean_dynamic_bindings
+            end
+          end
+        end
+
         protected
 
         def method_var_types

data/lib/typed/types/polymorphism/unification.rb

@@ -119,8 +119,14 @@ module TypedRb
               fn_arg = fn.from[i]
               if arg.is_a?(TypeVariable)
                 if graph[arg][:lower_type]
-                  type = compatible_lt_type?(graph[arg][:lower_type], fn_arg)
-                  graph[arg][:lower_type] = type
+                  begin
+                    type = [graph[arg][:lower_type], fn_arg].min
+                    graph[arg][:lower_type] = type
+                  rescue TypedRb::Types::Polymorphism::UnificationError
+                    value_l = graph[arg][:lower_type]
+                    value_r = fn_arg
+                    raise TypedRb::Types::UncomparableTypes.new(value_l, value_r, nil, ", #{value_l} cannot be compared to #{value_r}")
+                  end
                 else
                   graph[arg][:lower_type] = fn_arg
                 end
@@ -402,6 +408,7 @@ module TypedRb
           # in the remaining @lt constraints
           @lt_constraints = graph.replace_groups(@lt_constraints)
           unify(@lt_constraints)
+          graph.check_bindings
           unify(@send_constraints)
           graph.check_bindings
           graph.print_groups
@@ -462,7 +469,6 @@ module TypedRb
                 end
             text << "#{l} :send #{message}[ #{arg_types.join(',')} -> #{return_type}]\n"
           end
-
           TypedRb.log binding, :debug, text.string
         end
 

data/lib/typed/types/ty_generic_existential_type.rb

@@ -44,6 +44,13 @@ module TypedRb
         Polymorphism::Unification.new(applied_typing_context.all_constraints).run(false)
         applied_typing_context.unlink # these constraints have already been satisfied
       end
+
+      def clean_dynamic_bindings
+        type_vars.each do |type_var|
+          type_var.clean_dynamic_bindings
+        end
+        local_typing_context.clean_dynamic_bindings
+      end
     end
   end
 end

data/lib/typed/version.rb

@@ -1,5 +1,5 @@
 module TypedRb
   unless defined?(VERSION)
-    VERSION = '0.0.19'
+    VERSION = '0.0.20'
   end
 end

data/spec/lib/examples/enum.rb

@@ -0,0 +1,40 @@
+module Categories
+  ts 'type Categories::Enum[T]'
+  module Enum
+    ts '#succ / -> [T]'
+    abstract(:succ)
+
+    ts '#pred / -> [T]'
+    abstract(:pred)
+
+    ts '#to / [T] -> Array[T]'
+    def to(x)
+      xs = Array.('[T]').new
+      next_val = self
+      while(next_val != x)
+        xs.push(next_val)
+        next_val = next_val.succ
+      end
+      xs.push(next_val)
+      xs
+    end
+  end
+end
+
+
+ts 'type Integer super Categories::Enum[Integer]'
+class Integer
+  include Categories::Enum
+
+  def succ
+    self + 1
+  end
+
+  def pred
+    self - 1
+  end
+end
+
+3.to(10)
+
+

data/spec/lib/examples/enum/enum_error1.rb

@@ -0,0 +1,39 @@
+module Categories
+  ts 'type Categories::Enum[T]'
+  module Enum
+    ts '#succ / -> [T]'
+    abstract(:succ)
+
+    ts '#pred / -> [T]'
+    abstract(:pred)
+
+    ts '#to / [T] -> Array[T]'
+    def to(x)
+      xs = Array.('[T]').new
+      next_val = self
+      while(next_val != x)
+        xs.push(next_val)
+        next_val = next_val.succ
+      end
+      xs.push(next_val)
+      xs.push(true)
+      xs
+    end
+  end
+end
+
+
+ts 'type Integer super Categories::Enum[Integer]'
+class Integer
+  include Categories::Enum
+
+  def succ
+    self + 1
+  end
+
+  def pred
+    self - 1
+  end
+end
+
+3.to(10)

data/spec/lib/examples/equality.rb

@@ -0,0 +1,17 @@
+module Categories
+  ts 'type Categories::Equal[T]'
+  module Equal
+
+    ts '#eq? / [T] -> Boolean'
+    def eq?(o); self.eql?(o); end
+
+    ts '#not_eq? / [T] -> Boolean'
+    def not_eq?(o); ! self.eq?(o); end
+
+  end
+end
+
+ts 'type Integer super Categories::Equal[Integer]'
+class Integer
+  include Categories::Equal
+end

data/spec/lib/language_spec.rb

@@ -133,4 +133,40 @@ describe TypedRb::Language do
       }.to raise_error(TypedRb::Types::UncomparableTypes)
     end
   end
+
+  context 'with equality example, type checks correctly' do
+    let(:example) { 'equality.rb' }
+
+    it 'should be possible to type check the example correctly' do
+      expect {
+        silence_stream(STDOUT) do
+          language.check_file(file, true)
+        end
+      }.to_not raise_error
+    end
+  end
+
+  context 'with enum example, type checks correctly' do
+    let(:example) { 'enum.rb' }
+
+    it 'should be possible to type check the example correctly' do
+      expect {
+        expr = File.new(file, 'r').read
+        result = language.check(expr)
+        expect(result.to_s).to eq('Array[Integer]')
+      }.to_not raise_error
+    end
+  end
+
+  context 'with enum example error1, type checks correctly' do
+    let(:example) { 'enum/enum_error1.rb' }
+
+    it 'should be possible to type check the example correctly' do
+      expect {
+        expr = File.new(file, 'r').read
+        language.check(expr)
+      }.to raise_error(TypedRb::Types::Polymorphism::UnificationError)
+    end
+  end
+
 end

data/spec/lib/typing/generics_spec.rb

@@ -158,8 +158,7 @@ __END
 
     expect do
       language.check(code)
-    end.to raise_error(TypedRb::Types::UncomparableTypes,
-                       /Cannot compare types Object with.*Integer/)
+    end.to raise_error(TypedRb::Types::Polymorphism::UnificationError)
   end
 
   it 'type-checks correctly super type generics detecting type errors based on the super-type parameter on type instantiation' do
@@ -186,8 +185,7 @@ __END
 
     expect do
       language.check(code)
-    end.to raise_error(TypedRb::Types::UncomparableTypes,
-                       /Cannot compare types Object with.*Integer/)
+    end.to raise_error(TypedRb::Types::Polymorphism::UnificationError)
   end
 
 end

data/spec/lib/typing/tm_global_var_spec.rb

@@ -27,7 +27,7 @@ __END
 
       expect {
         language.check(expr)
-      }.to raise_error(TypedRb::Types::UncomparableTypes)
+      }.to raise_error(TypedRb::Types::Polymorphism::UnificationError)
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: typed.rb
 version: !ruby/object:Gem::Version
-  version: 0.0.19
+  version: 0.0.20
 platform: ruby
 authors:
 - Antonio Garrote
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-31 00:00:00.000000000 Z
+date: 2016-02-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser
@@ -150,6 +150,9 @@ files:
 - spec/lib/ast_parser_spec.rb
 - spec/lib/examples/animals.rb
 - spec/lib/examples/counter.rb
+- spec/lib/examples/enum.rb
+- spec/lib/examples/enum/enum_error1.rb
+- spec/lib/examples/equality.rb
 - spec/lib/examples/if.rb
 - spec/lib/examples/monoid.rb
 - spec/lib/examples/monoid/monoid_error1.rb
@@ -263,9 +266,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.6
+rubygems_version: 2.4.7
 signing_key: 
 specification_version: 4
 summary: Gradual type checker for Ruby
 test_files: []
-has_rdoc: