typed.rb 0.0.18 → 0.0.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 28e293212576b2bd00356a05305289b6e92587b7
-  data.tar.gz: 0c91a5c37a9dbe053232db6731c14fbe97f2991e
+  metadata.gz: 275c43f2dc819f16b312b04476aeb6e2348b901c
+  data.tar.gz: a3bee9cfa379440d26e4ed53d65bda969deeaa8c
 SHA512:
-  metadata.gz: 715899217f62a966e082d72e5686c2bc5b5ddc306861959420e71bc86f499bcec74317a109aa9fb1858ca7b7f104ef688c16ab6450e0ede990b64f4417c73663
-  data.tar.gz: 057c49cd5749900aff35435aee86e7ccdfc3810485284d0bca548ad588492d0ef8482902781421f06dadcb2436863cb6223bfac8b70f12431015bac14a5779a1
+  metadata.gz: d56e1eb679fc7443cb0f85da729c1680236cea4f6bf25e6eed316cb54ed5a1b5783cebc121ce5b34843060a1f97570f6f9f82eb42e9ab8c2712591fc6d6ae3d6
+  data.tar.gz: d3de0f7e334161c2e99e700efe52d0492e57b464d612413c5c86f069114e9393c94d2b8356270a509de8efb69471df627d7df879ce71f1eef9f6810fb19cdc25

data/lib/typed/language.rb

@@ -105,6 +105,7 @@ module TypedRb
           end
         end
       end
+
       top_level_errors = []
       begin
         ::BasicObject::TypeRegistry.check_super_type_annotations

data/lib/typed/runtime/type_registry.rb

@@ -29,21 +29,32 @@ class BasicObject
 
       ts '.register_generic_type_information / Hash[Object][Object] -> Hash[Object][Object] -> unit'
       def register_generic_type_information(generic_type_information, generic_super_types_information)
-        unless generic_type_information.is_a?(String) # TODO: String when super annotations for non-generic types
-          generic_type_information[:super_type] = generic_super_types_information
-          if generic_types_parser_registry[generic_type_information[:type]]
-            super_type = (generic_types_parser_registry[generic_type_information[:type]][:super_type] || [])
-            generic_types_parser_registry[generic_type_information[:type]][:super_type]= super_type.concat(generic_type_information[:super_type])
-          else
-            generic_types_parser_registry[generic_type_information[:type]] = generic_type_information
-          end
+        if generic_type_information.is_a?(String)
+          # concrete type with a generic super type
+          generic_type_information = {
+              :type => generic_type_information,
+              :parameters => [],
+              :kind => :generic_type
+          }
+        end
+        generic_type_information[:super_type] = generic_super_types_information
+        if generic_types_parser_registry[generic_type_information[:type]]
+          super_type = (generic_types_parser_registry[generic_type_information[:type]][:super_type] || [])
+          generic_types_parser_registry[generic_type_information[:type]][:super_type]= super_type.concat(generic_type_information[:super_type])
+        else
+          generic_types_parser_registry[generic_type_information[:type]] = generic_type_information
         end
       end
 
       def find_existential_type(type)
         existential_type = existential_types_registry[type]
         if existential_type.nil?
-          existential_type = TypedRb::Types::TyExistentialType.new(type)
+          generic_existential_type = generic_types_registry[type]
+          existential_type = if generic_existential_type
+                               TypedRb::Types::TyGenericExistentialType.new(type, generic_existential_type.type_vars)
+                             else
+                               TypedRb::Types::TyExistentialType.new(type)
+                             end
           @existential_types_registry[type] = existential_type
         end
         existential_type

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

@@ -31,8 +31,8 @@ module TypedRb
         def compatible?(other_type, relation = :lt)
           if other_type.is_a?(TyDynamic) || other_type.is_a?(TyError)
             true
-          elsif other_type.is_a?(TyGenericObject) || other_type.is_a?(TyGenericSingletonObject)
-            if check_generic_type_relation(other_type.ruby_type, relation)
+          elsif other_type.is_a?(TyGenericObject) || other_type.is_a?(TyGenericSingletonObject) || other_type.is_a?(TyGenericExistentialType)
+            if check_generic_type_relation(other_type, relation)
               type_vars.each_with_index do |type_var, i|
                 other_type_var = other_type.type_vars[i]
                 compatible = if incompatible_free_type_vars?(type_var, other_type_var)
@@ -49,7 +49,7 @@ module TypedRb
               false
             end
           elsif other_type.is_a?(TyObject)
-            check_generic_type_relation(other_type.ruby_type, relation)
+            check_generic_type_relation(other_type, relation)
           else
             other_type.compatible?(self, relation == :lt ? :gt : :lt)
           end
@@ -79,14 +79,25 @@ module TypedRb
              TypingContext.bound_generic_type_var?(right_var))
         end
 
-        def check_generic_type_relation(other_ruby_type, relation)
+        def check_generic_type_relation(other_type, relation)
           if relation == :gt
-            TyObject.new(ruby_type) >= TyObject.new(other_ruby_type)
+            to_ty_object(self)  >= to_ty_object(other_type)
           else
-            TyObject.new(ruby_type) <= TyObject.new(other_ruby_type)
+            to_ty_object(self)  <= to_ty_object(other_type)
           end
         end
 
+        def to_ty_object(type)
+          ty_object = TyObject.new(type.ruby_type)
+          if type.is_a?(Types::TySingletonObject) ||
+             type.is_a?(Types::TyGenericSingletonObject) ||
+             type.is_a?(Types::TyExistentialType) ||
+             type.is_a?(Types::TyGenericExistentialType)
+            ty_object.hierarchy = type.ruby_type.meta_ancestors
+          end
+          ty_object
+        end
+
         def check_type_var_inclusion(type_var, other_type_var, relation)
           if (!type_var.wildcard? && !type_var.fully_bound?) ||
              (!other_type_var.wildcard? && !other_type_var.fully_bound?)

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

@@ -107,6 +107,19 @@ module TypedRb
           i && type_vars[i]
         end
 
+        def to_s
+          base_string = super
+          var_types_strings = @type_vars.map do |var_type|
+            if var_type.respond_to?(:bound) && var_type.bound
+              # "[#{var_type.variable} <= #{var_type.bound}]"
+              "[#{var_type.bound}]"
+            else
+              "[#{var_type}]"
+            end
+          end
+          "#{base_string}#{var_types_strings.join}"
+        end
+
       end
     end
   end

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

@@ -163,10 +163,17 @@ module TypedRb
         end
 
         def [](var)
-          if var.is_a?(TypeVariable)
-            groups[var]
+          found = if var.is_a?(TypeVariable)
+                    groups[var]
+                  else
+                    var
+                  end
+          if found.nil?
+            var_key = groups.keys.detect{ |key| key.name == var.name }
+            found = groups[var_key]
+            found || raise(TypedRb::Types::Polymorphism::UnificationError.new("Unification error, cannot find type variable #{var}"))
           else
-            var
+            found
           end
         end
 

data/lib/typed/types/singleton_object.rb

@@ -0,0 +1,92 @@
+module TypedRb
+  module Types
+    module SingletonObject
+      def apply_type_arguments(fresh_vars_generic_type, actual_arguments)
+        fresh_vars_generic_type.type_vars.each_with_index do |type_var, i|
+          if type_var.bound.is_a?(TyGenericSingletonObject)
+            type_var.bind(apply_type_arguments_recursively(type_var.bound, actual_arguments))
+          else
+            apply_type_argument(actual_arguments[i], type_var)
+          end
+        end
+      end
+
+      def clone_with_substitutions(substitutions)
+        materialized_type_vars = type_vars(recursive: false).map do |type_var|
+          if type_var.is_a?(Polymorphism::TypeVariable) && type_var.bound_to_generic?
+            new_type_var = Polymorphism::TypeVariable.new(type_var.variable, node: type_var.node, gen_name: false)
+            new_type_var.to_wildcard! if type_var.wildcard?
+            bound = type_var.bound.clone_with_substitutions(substitutions)
+            new_type_var.bind(bound)
+            new_type_var.upper_bound = bound if type_var.upper_bound
+            new_type_var.lower_bound = bound if type_var.lower_bound
+            new_type_var
+          elsif type_var.is_a?(Polymorphism::TypeVariable)
+            substitutions[type_var.variable] || type_var.clone
+          elsif type_var.is_a?(TyGenericSingletonObject) || type_var.is_a?(TyGenericObject)
+            type_var.clone_with_substitutions(substitutions)
+          else
+            type_var
+          end
+        end
+        self.class.new(ruby_type, materialized_type_vars, node)
+      end
+
+      def apply_type_argument(argument, type_var)
+        if argument.is_a?(Polymorphism::TypeVariable)
+          if argument.wildcard?
+            # Wild card type
+            # If the type is T =:= E < Type1 or E > Type1 only that constraint should be added
+            { :lt => :upper_bound, :gt => :lower_bound }.each do |relation, bound|
+              if argument.send(bound)
+                value = if argument.send(bound).is_a?(TyGenericSingletonObject)
+                          argument.send(bound).clone # .self_materialize
+                        else
+                          argument.send(bound)
+                        end
+                type_var.compatible?(value, relation)
+              end
+            end
+            type_var.to_wildcard! # WILD CARD
+          elsif argument.bound # var type with a particular value
+            argument = argument.bound
+            if argument.is_a?(TyGenericSingletonObject)
+              argument = argument.clone # .self_materialize
+            end
+            # This is only for matches T =:= Type1 -> T < Type1, T > Type1
+            fail Types::UncomparableTypes.new(type_var, argument) unless type_var.compatible?(argument, :lt)
+            fail Types::UncomparableTypes.new(type_var, argument) unless type_var.compatible?(argument, :gt)
+          else
+            # Type variable
+            type_var.bound = argument
+            type_var.lower_bound = argument
+            type_var.upper_bound = argument
+          end
+        else
+          if argument.is_a?(TyGenericSingletonObject)
+            argument = argument.clone # .self_materialize
+          end
+          # This is only for matches T =:= Type1 -> T < Type1, T > Type1
+          fail Types::UncomparableTypes.new(type_var, argument) unless type_var.compatible?(argument, :lt)
+          fail Types::UncomparableTypes.new(type_var, argument) unless type_var.compatible?(argument, :gt)
+        end
+      end
+
+      def apply_type_arguments_recursively(generic_type_bound, actual_arguments)
+        arg_names = actual_arguments_hash(actual_arguments)
+        recursive_actual_arguments = generic_type_bound.type_vars.map do |type_var|
+          arg_names[type_var.variable] || fail("Unbound type variable #{type_var.variable} for recursive generic type #{generic_type_bound}")
+        end
+        generic_type_bound.materialize(recursive_actual_arguments)
+      end
+
+      def actual_arguments_hash(actual_arguments)
+        acc = {}
+        type_vars.each_with_index do |type_var, i|
+          acc[type_var.variable] = actual_arguments[i]
+        end
+        acc
+      end
+    end
+  end
+end

data/lib/typed/types/ty_generic_existential_type.rb

@@ -0,0 +1,49 @@
+require_relative 'ty_object'
+require_relative 'singleton_object'
+
+module TypedRb
+  module Types
+    class TyGenericExistentialType < TyExistentialType
+      include Polymorphism::GenericObject
+      include Polymorphism::GenericComparisons
+      include Polymorphism::GenericVariables
+      include SingletonObject
+
+      attr_accessor :local_typing_context, :self_variable
+
+      def initialize(ruby_type, type_vars, node = nil)
+        super(ruby_type, node)
+        @type_vars = type_vars
+      end
+
+      def check_inclusion(self_type)
+        if self_type.generic?
+          if ancestor_of_super_type?(self_type.super_type, ruby_type)
+            super_type = ancestor_of_super_type?(self_type.super_type, ruby_type)
+            materialize(self_type, super_type.type_vars)
+          else
+            materialize(self_type, self_type.type_vars)
+          end
+        else
+          # not generic extending a generic type
+          raise StandardError, "Extending generic module type #{ruby_type} in #{self_type} without matching super annotation"
+        end
+      end
+
+      def materialize(self_type, actual_arguments)
+        TypedRb.log binding, :debug, "Materialising generic existential type '#{self}' with args [#{actual_arguments.map(&:to_s).join(',')}]"
+        compute_minimal_typing_context if @local_typing_context.nil?
+
+        applied_typing_context, substitutions = @local_typing_context.clone(:module_self)
+        fresh_vars_generic_type = clone_with_substitutions(substitutions)
+        TypingContext.with_context(applied_typing_context) do
+          apply_type_arguments(fresh_vars_generic_type, actual_arguments)
+          context_self_type = Types::TypingContext.type_variable_for(ruby_type, :module_self, [ruby_type])
+          context_self_type.compatible?(self_type, :lt)
+        end
+        Polymorphism::Unification.new(applied_typing_context.all_constraints).run(false)
+        applied_typing_context.unlink # these constraints have already been satisfied
+      end
+    end
+  end
+end

data/lib/typed/types/ty_generic_object.rb

@@ -37,19 +37,6 @@ module TypedRb
         end
       end
 
-      def to_s
-        base_string = super
-        var_types_strings = @type_vars.map do |var_type|
-          if var_type.respond_to?(:bound) && var_type.bound
-            # "[#{var_type.variable} <= #{var_type.bound}]"
-            "[#{var_type.bound}]"
-          else
-            "[#{var_type}]"
-          end
-        end
-        "#{base_string}#{var_types_strings.join}"
-      end
-
       def clone_with_substitutions(substitutions)
         materialized_type_vars = type_vars(recursive: false).map do |type_var|
           if type_var.is_a?(Polymorphism::TypeVariable)
@@ -74,7 +61,6 @@ module TypedRb
         end
         self
       end
-
     end
   end
 end

data/lib/typed/types/ty_generic_singleton_object.rb

@@ -2,6 +2,7 @@ require_relative 'ty_singleton_object'
 require_relative 'polymorphism/generic_comparisons'
 require_relative 'polymorphism/generic_variables'
 require_relative 'polymorphism/generic_object'
+require_relative 'singleton_object'
 
 module TypedRb
   module Types
@@ -9,6 +10,7 @@ module TypedRb
       include Polymorphism::GenericObject
       include Polymorphism::GenericComparisons
       include Polymorphism::GenericVariables
+      include SingletonObject
 
       attr_accessor :local_typing_context, :super_type
 
@@ -82,26 +84,6 @@ module TypedRb
         fresh_vars_generic_type.apply_bindings(unification.bindings_map)
       end
 
-      # TODO: We do need this for cases like Array.(Int).class_method
-
-      # def find_function_type(message)
-      #   function_type = BasicObject::TypeRegistry.find(:class, ruby_type, message)
-      #   replace_bound_type_vars(function_type, type_vars)
-      # end
-
-      #          def find_function_type(message)
-      #            BasicObject::TypeRegistry.find(:class, ruby_type, message)
-      #          end
-      #
-      #          def find_var_type(var)
-      #            var_type = BasicObject::TypeRegistry.find(:class_variable, ruby_type, var)
-      #            if var_type
-      #              var_type
-      #            else
-      #              Types::TypingContext.type_variable_for(:class_variable, var, hierarchy)
-      #            end
-      #          end
-
       def as_object_type
         # this should only be used to check the body type of this
         # class. The variables are going to be unbound.
@@ -131,41 +113,6 @@ module TypedRb
         TyGenericSingletonObject.new(ruby_type, cloned_type_vars, super_type, node)
       end
 
-      def to_s
-        base_string = super
-        var_types_strings = @type_vars.map do |var_type|
-          if !var_type.is_a?(Polymorphism::TypeVariable)
-            "[#{var_type}]"
-          elsif var_type.bound && var_type.bound.is_a?(Polymorphism::TypeVariable)
-            "[#{var_type.variable} <= #{var_type.bound.bound || var_type.bound.variable}]"
-          else
-            "[#{var_type.bound || var_type.variable}]"
-          end
-        end
-        "#{base_string}#{var_types_strings.join}"
-      end
-
-      def clone_with_substitutions(substitutions)
-        materialized_type_vars = type_vars(recursive: false).map do |type_var|
-          if type_var.is_a?(Polymorphism::TypeVariable) && type_var.bound_to_generic?
-            new_type_var = Polymorphism::TypeVariable.new(type_var.variable, node: type_var.node, gen_name: false)
-            new_type_var.to_wildcard! if type_var.wildcard?
-            bound = type_var.bound.clone_with_substitutions(substitutions)
-            new_type_var.bind(bound)
-            new_type_var.upper_bound = bound if type_var.upper_bound
-            new_type_var.lower_bound = bound if type_var.lower_bound
-            new_type_var
-          elsif type_var.is_a?(Polymorphism::TypeVariable)
-            substitutions[type_var.variable] || type_var.clone
-          elsif type_var.is_a?(TyGenericSingletonObject) || type_var.is_a?(TyGenericObject)
-            type_var.clone_with_substitutions(substitutions)
-          else
-            type_var
-          end
-        end
-        self.class.new(ruby_type, materialized_type_vars, super_type, node)
-      end
-
       # This object has concrete type parameters
       # The generic Function we retrieve from the registry might be generic
       # If it is generic we apply the bound parameters and we obtain a concrete function type
@@ -188,73 +135,6 @@ module TypedRb
         end
       end
 
-      protected
-
-      def apply_type_arguments(fresh_vars_generic_type, actual_arguments)
-        fresh_vars_generic_type.type_vars.each_with_index do |type_var, i|
-          if type_var.bound.is_a?(TyGenericSingletonObject)
-            type_var.bind(apply_type_arguments_recursively(type_var.bound, actual_arguments))
-          else
-            apply_type_argument(actual_arguments[i], type_var)
-          end
-        end
-      end
-
-      def apply_type_argument(argument, type_var)
-        if argument.is_a?(Polymorphism::TypeVariable)
-          if argument.wildcard?
-            # Wild card type
-            # If the type is T =:= E < Type1 or E > Type1 only that constraint should be added
-            { :lt => :upper_bound, :gt => :lower_bound }.each do |relation, bound|
-              if argument.send(bound)
-                value = if argument.send(bound).is_a?(TyGenericSingletonObject)
-                          argument.send(bound).clone # .self_materialize
-                        else
-                          argument.send(bound)
-                        end
-                type_var.compatible?(value, relation)
-              end
-            end
-            type_var.to_wildcard! # WILD CARD
-          elsif argument.bound # var type with a particular value
-            argument = argument.bound
-            if argument.is_a?(TyGenericSingletonObject)
-              argument = argument.clone # .self_materialize
-            end
-            # This is only for matches T =:= Type1 -> T < Type1, T > Type1
-            fail Types::UncomparableTypes.new(type_var, argument) unless type_var.compatible?(argument, :lt)
-            fail Types::UncomparableTypes.new(type_var, argument) unless type_var.compatible?(argument, :gt)
-          else
-            # Type variable
-            type_var.bound = argument
-            type_var.lower_bound = argument
-            type_var.upper_bound = argument
-          end
-        else
-          if argument.is_a?(TyGenericSingletonObject)
-            argument = argument.clone # .self_materialize
-          end
-          # This is only for matches T =:= Type1 -> T < Type1, T > Type1
-          fail Types::UncomparableTypes.new(type_var, argument) unless type_var.compatible?(argument, :lt)
-          fail Types::UncomparableTypes.new(type_var, argument) unless type_var.compatible?(argument, :gt)
-        end
-      end
-
-      def apply_type_arguments_recursively(generic_type_bound, actual_arguments)
-        arg_names = actual_arguments_hash(actual_arguments)
-        recursive_actual_arguments = generic_type_bound.type_vars.map do |type_var|
-          arg_names[type_var.variable] || fail("Unbound type variable #{type_var.variable} for recursive generic type #{generic_type_bound}")
-        end
-        generic_type_bound.materialize(recursive_actual_arguments)
-      end
-
-      def actual_arguments_hash(actual_arguments)
-        acc = {}
-        type_vars.each_with_index do |type_var, i|
-          acc[type_var.variable] = actual_arguments[i]
-        end
-        acc
-      end
     end
   end
 end

data/lib/typed/types/ty_object.rb

@@ -19,7 +19,8 @@ module TypedRb
     class TyObject < Type
       include Comparable
 
-      attr_reader :hierarchy, :classes, :modules, :ruby_type, :with_ruby_type
+      attr_reader :classes, :modules, :ruby_type, :with_ruby_type
+      attr_accessor :hierarchy
 
       def initialize(ruby_type, node = nil, classes = [], modules = [])
         super(node)

data/lib/typed/version.rb

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

data/spec/lib/typing/tm_module_spec.rb

@@ -86,4 +86,107 @@ __CODE
     result = language.check(code)
     expect(result.ruby_type).to eq(Integer)
   end
+
+  it 'typechecks the inclusion of a polymorphic module into a class' do
+    code = <<__CODE
+     module TMod5
+       ts '#head[T] / Array[T] -> [T]'
+       def head(xs); xs.first; end
+     end
+
+     class TMod5C
+        include TMod5
+     end
+
+     TMod5C.new.head([1,2,3])
+__CODE
+
+    result = language.check(code)
+    expect(result.ruby_type).to eq(Integer)
+  end
+
+  it 'typechecks the inclusion of a polymorphic nested module into a class' do
+    code = <<__CODE
+    module Categories
+      module Polymorphism
+
+        ts '#head[A] / Array[A] -> [A]'
+        def head(xs)
+          xs.first
+        end
+
+      end
+    end
+
+    include Categories::Polymorphism
+
+    head([1,2,3])
+__CODE
+
+    result = language.check(code)
+    expect(result.ruby_type).to eq(Integer)
+  end
+
+  it 'typechecks the inclusion of a polymorphic module into the top level object' do
+    code = <<__CODE
+     module TMod5
+       ts '#head[T] / Array[T] -> [T]'
+       def head(xs); xs.first; end
+     end
+
+     include TMod5
+
+     head([1,2,3])
+__CODE
+
+    result = language.check(code)
+    expect(result.ruby_type).to eq(Integer)
+  end
+
+  it 'typechecks modules with generic parameters' do
+    code = <<__CODE
+    ts 'type TMod6[T]'
+    module TMod6
+       ts '#test1 / Array[T] -> [T]'
+       def test1(x); x.first; end
+    end
+
+    ts 'type TestTMod6 super TMod6[String]'
+    class TestTMod6
+      include TMod6
+    end
+
+    TestTMod6.new.test1(['a','b','c'])
+__CODE
+
+    result = language.check(code)
+    expect(result.ruby_type).to eq(String)
+  end
+
+   it 'typechecks modules with generic parameters 2' do
+    code = <<__CODE
+  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 String super Categories::Equal[String]'
+  class String
+    include Categories::Equal
+  end
+
+  "test".eq? "other"
+__CODE
+
+    result = language.check(code)
+    expect(result.to_s).to eq('Boolean')
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: typed.rb
 version: !ruby/object:Gem::Version
-  version: 0.0.18
+  version: 0.0.19
 platform: ruby
 authors:
 - Antonio Garrote
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-29 00:00:00.000000000 Z
+date: 2016-01-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser
@@ -130,12 +130,14 @@ files:
 - lib/typed/types/polymorphism/type_variable.rb
 - lib/typed/types/polymorphism/type_variable_register.rb
 - lib/typed/types/polymorphism/unification.rb
+- lib/typed/types/singleton_object.rb
 - lib/typed/types/ty_boolean.rb
 - lib/typed/types/ty_dynamic.rb
 - lib/typed/types/ty_either.rb
 - lib/typed/types/ty_error.rb
 - lib/typed/types/ty_existential_type.rb
 - lib/typed/types/ty_function.rb
+- lib/typed/types/ty_generic_existential_type.rb
 - lib/typed/types/ty_generic_function.rb
 - lib/typed/types/ty_generic_object.rb
 - lib/typed/types/ty_generic_singleton_object.rb
@@ -261,8 +263,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5.1
+rubygems_version: 2.4.6
 signing_key: 
 specification_version: 4
 summary: Gradual type checker for Ruby
 test_files: []
+has_rdoc: