typed.rb 0.0.16 → 0.0.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ac43557e5bdf48bfa8082e5526b798e7a2fc3aca
-  data.tar.gz: ed3a52ee31070c01b9dff44e8decd67bbabac035
+  metadata.gz: f2c8f6d09d1aaaa16400b98c8303b0f33d0776e5
+  data.tar.gz: b7a8374f668d3af8aba103fe87f5ba2b9224ec4c
 SHA512:
-  metadata.gz: 06c43f6cc812fa5b98a53e4d5e556fce63492746241f618ead568a04bcb018ec83a239891484168b692927699eb4fc7fa8793bf514cb3bf2bbcce790ee902e3f
-  data.tar.gz: 9fa398a80e4c0e57807df2ae73538176e2ffb1d9b1c2387a3c4aba0a28e43898df5c82fc0ce715f9318c3f249fecffeab4529792981676b7c109cf2f06c56868
+  metadata.gz: a003f890681c58cb00c8be8ca3ee3f976a7cfaecd38df6d671119e29b76853c82724427af5b0b0a2975b18a20c13df0203ec95c470ef6ce5c51ed073aa37f893
+  data.tar.gz: 415c505025c2dedca743ccd46b62ddc16a719570d599b40ac3824b63713adab342c46f5f3abd2a17328a2c1832609074a05034a0e6d5c3a671522b7d5f0aeb7d

data/README.md

@@ -139,6 +139,47 @@ type TypeName[T]? (super BaseType[U]*)?
 - ```[T]*``` type variables for the polymorphic type
 - ```(super BaseType[U]*)?``` base polymorphic class/module for the type
 
+## Polymorphism
+
+Typed.rb supports annotations for polymorphic types and methods. Type variables are introduced using square brackets and a capital letter (e.g ```[T]```).
+When creating an instance of a polymorphic type in your code, information about the specialization of the type variables must be provided. The Typed.rb runtime defines a version of the ```#call`` method for the ```Class``` class as a noop that can be used to pass the value of the type variables.
+For example, to declare an ```Array``` of ```Integers``` the following code can be used:
+
+```ruby
+xs = Array.(Integer).new
+```
+Instead of a class, a string with the description of the type variables using the same syntax as the one used in the type annotations can be used.
+The previous definition could be expressed in an equivalent way using the following snippet:
+
+```ruby
+xs = Array.('Integer').new
+```
+
+Using a string is the only option when dealing with type vars as in the following declaration:
+
+```ruby
+ts 'type Wrapper[T]'
+class Wrapper
+
+  ts '#zero / -> Array[T]'
+  def zero
+   Array.('[T]').new
+  end
+
+end
+```
+
+If no value for the type variables of the polymorphic type are given, the type checker will assume that ```Object``` is used.
+
+When initiating objects using type literals, like arrays or hashes, the type checker will try to infer the type variables using the max type for the provided values in the literal:
+
+```ruby
+[1, 2, 3]    # Array[Integer]
+[1, :2, '3'] # Array[Object]
+```
+
+Type boundaries can be provided for the type variables using the ```?```, ```<``` and ```>``` symbols, where ```?``` is used as type wildcard, for instance: ```[? < Integer]```, ```[? > String]```. ```[?]```.
+
 
 ## Type inference and minimal typing
 

data/lib/typed/runtime/normalization.rb

@@ -62,6 +62,7 @@ module TypedRb
       def valid_super_type?(base_class, super_type_info)
         return false if super_type_info.nil?
         valid = base_class.ancestors.map(&:name).detect { |klass_name| klass_name == super_type_info[:type].to_s }
+        valid = valid || base_class.meta_ancestors.map(&:name).detect { |klass_name| klass_name == super_type_info[:type].to_s }
         return true if valid
         fail ::TypedRb::Types::TypeParsingError,
              "Super type annotation '#{super_type_info[:type]}' not a super class of '#{base_class}'"

data/lib/typed/runtime.rb

@@ -30,7 +30,7 @@ class BasicObject
 end
 
 class Class
-  ts '.call / Class... -> unit'
+  ts '.call / Object... -> Class'
   def call(*_types)
     self
   end

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

@@ -0,0 +1,114 @@
+module TypedRb
+  module Types
+    module Polymorphism
+      module GenericObject
+        def generic?
+          true
+        end
+
+        def generic_singleton_object
+          @generic_singleton_object ||= BasicObject::TypeRegistry.find_generic_type(ruby_type)
+        end
+
+        def ancestor_of_super_type?(super_type_klasses, function_klass_type)
+          super_type_klasses.detect do |super_type_klass|
+            super_type_klass.ruby_type.ancestors.include?(function_klass_type)
+          end
+        end
+
+        def materialize_super_type_found_function(message, num_args, block,
+                                                  super_type,
+                                                  super_type_vars)
+          super_type_materialization_args = parse_super_type_materialization_args(super_type_vars)
+          # we build the concrete type for the arguments based in the subclass bindings and the
+          # super type parsed value
+          materialized_super_type_in_context = super_type.materialize(super_type_materialization_args).type_vars(recursive: false)
+          # Now we check if the parsed type is valid  provided the constraints of the super class
+          super_type_generic_object = BasicObject::TypeRegistry.find_generic_type(super_type.ruby_type)
+          materialized_super_type = super_type_generic_object.materialize(materialized_super_type_in_context)
+
+          # materialized_super_type.type_vars = super_type.type_vars # ...
+          materialized_super_type.as_object_type.find_function_type(message, num_args, block)
+        end
+
+        def parse_super_type_materialization_args(super_type_vars)
+          super_type_vars.map do |super_type_var|
+            parse_super_type_materialization_arg(super_type_var)
+          end
+        end
+
+        def parse_super_type_materialization_arg(super_type_var)
+          return super_type_var if super_type_var.bound
+          found_matching_var = type_vars.detect do |var|
+            var_name = var.name.split(':').last
+            super_type_var.name.index(var_name)
+          end
+          if found_matching_var
+            base_matching_var = found_matching_var.dup
+            base_matching_var.name = super_type_var.name
+            base_matching_var.variable = super_type_var.variable
+            base_matching_var
+          else
+            fail TypedRb::TypeCheckError,
+                 "Error materializing super type annotation for variable #{generic_singleton_object.ruby_type} '#{super_type_var.split(':').last}' not found in base class #{ruby_type}"
+          end
+        end
+
+        def materialize_found_function(function_type)
+          return function_type unless function_type.generic?
+          from_args = function_type.from.map { |arg| materialize_found_function_arg(arg) }
+          to_arg = materialize_found_function_arg(function_type.to)
+          if function_type.block_type
+            materialized_block_type = materialize_found_function(function_type.block_type)
+          end
+
+          generic_function = (from_args + [to_arg, materialized_block_type]).any? do |arg|
+            arg.is_a?(Polymorphism::TypeVariable) ||
+                (arg.respond_to?(:generic?) && arg.generic?)
+          end
+
+          if generic_function
+            materialized_function = TyGenericFunction.new(from_args, to_arg, function_type.parameters_info, node)
+            materialized_function.local_typing_context = function_type.local_typing_context
+          else
+            materialized_function = TyFunction.new(from_args, to_arg, function_type.parameters_info, node)
+          end
+
+          materialized_function.with_block_type(materialized_block_type)
+        end
+
+        def materialize_found_function_arg(arg)
+          if arg.is_a?(Polymorphism::TypeVariable)
+            matching_var = generic_type_var_to_applied_type_var(arg)
+
+            # if matching_var && matching_var.wildcard? && matching_var.lower_bound
+            #  matching_var.lower_bound
+            # elsif matching_var
+            # WILDCARD
+            if matching_var
+              # Type variables and generic methods => function will still be generic
+              (matching_var.is_a?(Polymorphism::TypeVariable) && matching_var.bound) || matching_var
+            else
+              # generic_function = true
+              # TyUnboundType.new(matching_var.variable, :lower_bound)
+              # fail TypeCheckError, "Cannot find matching type var for #{arg.variable} instantiating #{self}", arg.node
+              # method generic var?
+              arg
+            end
+          elsif arg.is_a?(TyGenericSingletonObject)
+            arg.materialize_with_type_vars(type_vars, :lower_bound).as_object_type
+          else
+            arg
+          end
+        end
+
+        def generic_type_var_to_applied_type_var(type_var)
+          i = TypeRegistry.find_generic_type(ruby_type).type_vars.find_index { |generic_type_var| generic_type_var.variable == type_var.variable }
+          i && type_vars[i]
+        end
+
+      end
+    end
+  end
+end
+

data/lib/typed/types/ty_generic_object.rb

@@ -1,9 +1,12 @@
 require_relative 'ty_object'
 require_relative 'polymorphism/generic_comparisons'
 require_relative 'polymorphism/generic_variables'
+require_relative 'polymorphism/generic_object'
+
 module TypedRb
   module Types
     class TyGenericObject < TyObject
+      include Polymorphism::GenericObject
       include Polymorphism::GenericComparisons
       include Polymorphism::GenericVariables
 
@@ -34,102 +37,6 @@ module TypedRb
         end
       end
 
-      def generic?
-        true
-      end
-
-      def materialize_found_function(function_type)
-        return function_type unless function_type.generic?
-        from_args = function_type.from.map { |arg| materialize_found_function_arg(arg) }
-        to_arg = materialize_found_function_arg(function_type.to)
-        if function_type.block_type
-          materialized_block_type = materialize_found_function(function_type.block_type)
-        end
-
-        generic_function = (from_args + [to_arg, materialized_block_type]).any? do |arg|
-          arg.is_a?(Polymorphism::TypeVariable) ||
-          (arg.respond_to?(:generic?) && arg.generic?)
-        end
-
-        if generic_function
-          materialized_function = TyGenericFunction.new(from_args, to_arg, function_type.parameters_info, node)
-          materialized_function.local_typing_context = function_type.local_typing_context
-        else
-          materialized_function = TyFunction.new(from_args, to_arg, function_type.parameters_info, node)
-        end
-
-        materialized_function.with_block_type(materialized_block_type)
-      end
-
-      def materialize_super_type_found_function(message, num_args, block,
-                                                super_type,
-                                                super_type_vars)
-        super_type_materialization_args = parse_super_type_materialization_args(super_type_vars)
-        # we build the concrete type for the arguments based in the subclass bindings and the
-        # super type parsed value
-        materialized_super_type_in_context = super_type.materialize(super_type_materialization_args).type_vars(recursive: false)
-        # Now we check if the parsed type is valid  provided the constraints of the super class
-        super_type_generic_object = BasicObject::TypeRegistry.find_generic_type(super_type.ruby_type)
-        materialized_super_type = super_type_generic_object.materialize(materialized_super_type_in_context)
-
-        # materialized_super_type.type_vars = super_type.type_vars # ...
-        materialized_super_type.as_object_type.find_function_type(message, num_args, block)
-      end
-
-      def parse_super_type_materialization_args(super_type_vars)
-        super_type_vars.map do |super_type_var|
-          parse_super_type_materialization_arg(super_type_var)
-        end
-      end
-
-      def parse_super_type_materialization_arg(super_type_var)
-        return super_type_var if super_type_var.bound
-        found_matching_var = type_vars.detect do |var|
-          var_name = var.name.split(':').last
-          super_type_var.name.index(var_name)
-        end
-        if found_matching_var
-          base_matching_var = found_matching_var.dup
-          base_matching_var.name = super_type_var.name
-          base_matching_var.variable = super_type_var.variable
-          base_matching_var
-        else
-          fail TypedRb::TypeCheckError,
-               "Error materializing super type annotation for variable #{generic_singleton_object.ruby_type} '#{super_type_var.split(':').last}' not found in base class #{ruby_type}"
-        end
-      end
-
-      def ancestor_of_super_type?(super_type_klasses, function_klass_type)
-        super_type_klasses.detect do |super_type_klass|
-            super_type_klass.ruby_type.ancestors.include?(function_klass_type)
-        end
-      end
-
-      def materialize_found_function_arg(arg)
-        if arg.is_a?(Polymorphism::TypeVariable)
-          matching_var = generic_type_var_to_applied_type_var(arg)
-
-          # if matching_var && matching_var.wildcard? && matching_var.lower_bound
-          #  matching_var.lower_bound
-          # elsif matching_var
-          # WILDCARD
-          if matching_var
-            # Type variables and generic methods => function will still be generic
-            (matching_var.is_a?(Polymorphism::TypeVariable) && matching_var.bound) || matching_var
-          else
-            # generic_function = true
-            # TyUnboundType.new(matching_var.variable, :lower_bound)
-            # fail TypeCheckError, "Cannot find matching type var for #{arg.variable} instantiating #{self}", arg.node
-            # method generic var?
-            arg
-          end
-        elsif arg.is_a?(TyGenericSingletonObject)
-          arg.materialize_with_type_vars(type_vars, :lower_bound).as_object_type
-        else
-          arg
-        end
-      end
-
       def to_s
         base_string = super
         var_types_strings = @type_vars.map do |var_type|
@@ -168,14 +75,6 @@ module TypedRb
         self
       end
 
-      def generic_singleton_object
-        @generic_singleton_object ||= BasicObject::TypeRegistry.find_generic_type(ruby_type)
-      end
-
-      def generic_type_var_to_applied_type_var(type_var)
-        i = TypeRegistry.find_generic_type(ruby_type).type_vars.find_index { |generic_type_var| generic_type_var.variable == type_var.variable }
-        i && type_vars[i]
-      end
     end
   end
 end

data/lib/typed/types/ty_generic_singleton_object.rb

@@ -1,10 +1,12 @@
 require_relative 'ty_singleton_object'
 require_relative 'polymorphism/generic_comparisons'
 require_relative 'polymorphism/generic_variables'
+require_relative 'polymorphism/generic_object'
 
 module TypedRb
   module Types
     class TyGenericSingletonObject < TySingletonObject
+      include Polymorphism::GenericObject
       include Polymorphism::GenericComparisons
       include Polymorphism::GenericVariables
 
@@ -111,10 +113,6 @@ module TypedRb
         Model::TmClass.with_fresh_bindings(self, nil, node)
       end
 
-      def generic?
-        true
-      end
-
       def apply_bindings(bindings_map)
         type_vars(recursive: false).each_with_index do |var, _i|
           if var.is_a?(Polymorphism::TypeVariable) && var.bound_to_generic?
@@ -168,6 +166,28 @@ module TypedRb
         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
+      def find_function_type(message, num_args, block)
+        function_klass_type, function_type = super(message, num_args, block)
+        if function_klass_type != ruby_type && ancestor_of_super_type?(generic_singleton_object.super_type, function_klass_type)
+          target_class = ancestor_of_super_type?(generic_singleton_object.super_type, function_klass_type)
+          TypedRb.log binding, :debug, "Found message '#{message}', generic function: #{function_type}, explicit super type #{target_class}"
+          target_type_vars = target_class.type_vars
+          materialize_super_type_found_function(message, num_args, block, target_class, target_type_vars)
+        elsif function_klass_type != ruby_type && BasicObject::TypeRegistry.find_generic_type(function_klass_type)
+          TypedRb.log binding, :debug, "Found message '#{message}', generic function: #{function_type}, implict super type #{function_klass_type}"
+          target_class = BasicObject::TypeRegistry.find_generic_type(function_klass_type)
+          materialize_super_type_found_function(message, num_args, block, target_class, type_vars)
+        else
+          TypedRb.log binding, :debug, "Found message '#{message}', generic function: #{function_type}"
+          materialized_function = materialize_found_function(function_type)
+          TypedRb.log binding, :debug, "Found message '#{message}', materialized generic function: #{materialized_function}"
+          [function_klass_type, materialized_function]
+        end
+      end
+
       protected
 
       def apply_type_arguments(fresh_vars_generic_type, actual_arguments)

data/lib/typed/version.rb

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

data/spec/lib/examples/monoid2/monoid2_error1.rb

@@ -0,0 +1,39 @@
+require 'typed/runtime'
+
+module Monoid
+
+  ts 'type Monoid::Instance[T]'
+  module Instance
+    ts '#mappend / [T] -> [T]'
+    abstract(:mappend)
+  end
+
+  ts 'type Monoid::Class[T]'
+  module Class
+    ts '#mempty / -> [T]'
+    abstract(:mempty)
+  end
+end
+
+ts 'type Array[T] super Monoid::Instance[Array[T]]'
+ts 'type Array[T] super Monoid::Class[Array[T]]'
+class Array
+
+  extend Monoid::Class
+  include Monoid::Instance
+
+  def mappend(b)
+    concat(b)
+  end
+
+  def self.mempty
+    []
+  end
+
+end
+
+a = Array.(String).mempty
+
+->() {
+  a.mappend([2])
+}

data/spec/lib/examples/monoid2.rb

@@ -16,6 +16,7 @@ module Monoid
 end
 
 ts 'type Array[T] super Monoid::Instance[Array[T]]'
+ts 'type Array[T] super Monoid::Class[Array[T]]'
 class Array
 
   extend Monoid::Class
@@ -31,4 +32,8 @@ class Array
 
 end
 
-Array.(Integer).new.mappend([3])
+a = Array.(String).mempty
+
+->() {
+  a.mappend(['string'])
+}

data/spec/lib/language_spec.rb

@@ -62,7 +62,7 @@ describe TypedRb::Language do
     end
   end
 
-  context 'with monoid error example, inconsistent type annotation' do
+  context 'with monoid error example 1, inconsistent type annotation' do
     let(:example) { 'monoid/monoid_error1.rb' }
 
     it 'should be possible to type check the example correctly' do
@@ -74,7 +74,7 @@ describe TypedRb::Language do
     end
   end
 
-  context 'with monoid error example, inconsistent type annotation' do
+  context 'with monoid error example 2, inconsistent type annotation' do
     let(:example) { 'monoid/monoid_error2.rb' }
 
     it 'should be possible to type check the example correctly' do
@@ -86,7 +86,7 @@ describe TypedRb::Language do
     end
   end
 
-  context 'with monoid error example, inconsistent type annotation' do
+  context 'with monoid error example 3, inconsistent type annotation' do
     let(:example) { 'monoid/monoid_error3.rb' }
 
     it 'should be possible to type check the example correctly' do
@@ -98,7 +98,7 @@ describe TypedRb::Language do
     end
   end
 
-  context 'with monoid error example, inconsistent type annotation' do
+  context 'with monoid error example 4, inconsistent type annotation' do
     let(:example) { 'monoid/monoid_error4.rb' }
 
     it 'should be possible to type check the example correctly' do
@@ -121,4 +121,16 @@ describe TypedRb::Language do
       }.to_not raise_error
     end
   end
+
+  context 'with monoid2 error example 1, inconsistent type' do
+    let(:example) { 'monoid2/monoid2_error1.rb' }
+
+    it 'should be possible to type check the example correctly' do
+      expect {
+        silence_stream(STDOUT) do
+          language.check_file(file, true)
+        end
+      }.to raise_error(TypedRb::Types::UncomparableTypes)
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: typed.rb
 version: !ruby/object:Gem::Version
-  version: 0.0.16
+  version: 0.0.17
 platform: ruby
 authors:
 - Antonio Garrote
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-27 00:00:00.000000000 Z
+date: 2016-01-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser
@@ -124,6 +124,7 @@ files:
 - lib/typed/types.rb
 - lib/typed/types/polymorphism/existential_type_variable.rb
 - lib/typed/types/polymorphism/generic_comparisons.rb
+- lib/typed/types/polymorphism/generic_object.rb
 - lib/typed/types/polymorphism/generic_variables.rb
 - lib/typed/types/polymorphism/type_variable.rb
 - lib/typed/types/polymorphism/type_variable_register.rb
@@ -153,6 +154,7 @@ files:
 - spec/lib/examples/monoid/monoid_error3.rb
 - spec/lib/examples/monoid/monoid_error4.rb
 - spec/lib/examples/monoid2.rb
+- spec/lib/examples/monoid2/monoid2_error1.rb
 - spec/lib/language_spec.rb
 - spec/lib/model/tm_abs_spec.rb
 - spec/lib/model/tm_array_literal_spec.rb