finitio 0.7.0.pre.rc4 → 0.10.0

data/lib/finitio/syntax/type/high_order_vars.rb

@@ -0,0 +1,16 @@
+module Finitio
+  module Syntax
+    module HighOrderVars
+      include Node
+
+      def compile(system)
+        captures[:type_name].map{|c| c.to_s }
+      end
+
+      def to_ast(var_name)
+        [ :high_order_vars, captures[:type_name].map{|c| c.to_s } ]
+      end
+
+    end # module HighOrderVars
+  end # module Syntax
+end # module Finitio

data/lib/finitio/syntax/type/type_def.rb

@@ -5,9 +5,19 @@ module Finitio
 
       capture :type
       capture :type_name
+      capture :vars
 
       def compile(system)
-        t = type.compile(system)
+        if vars
+          vs = vars.compile(system)
+          overrides = Hash[vs.map{|v|
+            [ v.to_s, ProxyType.new(v) ]
+          }]
+          t = type.compile(system.with_scope(overrides))
+          t = HighOrderType.new(vs, t)
+        else
+          t = type.compile(system)
+        end
         n = type_name && type_name.to_str
         m = metadata
         system.add_type(t, n, m)

data/lib/finitio/syntax/types.citrus

@@ -6,10 +6,15 @@ grammar Finitio::Syntax::Types
   include Finitio::Syntax::Literals
 
   rule type_def
-    (metadata? type_name equal type)
+    (metadata? type_name ('<' vars:high_order_vars '>')? equal type)
     <Finitio::Syntax::TypeDef>
   end
 
+  rule high_order_vars
+    (type_name (comma type_name)*)
+    <Finitio::Syntax::HighOrderVars>
+  end
+
   rule main_type
     (metadata? type)
     <Finitio::Syntax::MainType>
@@ -58,6 +63,7 @@ grammar Finitio::Syntax::Types
   rule rel_type
       relation_type
     | tuple_type
+    | high_order_type_instantiation
     | collection_type
   end
 
@@ -110,6 +116,13 @@ grammar Finitio::Syntax::Types
     <Finitio::Syntax::StructType>
   end
 
+  # high-order types
+
+  rule high_order_type_instantiation
+    (high:type_name '<' vars:high_order_vars '>')
+    <Finitio::Syntax::HighOrderTypeInstantiation>
+  end
+
   # terminal forms
 
   rule term_type

data/lib/finitio/system.rb

@@ -10,7 +10,7 @@ module Finitio
     end
 
     attr_reader :types, :imports
-    private :types, :imports
+    private :imports
 
     def add_import(system)
       @imports << system
@@ -89,6 +89,16 @@ module Finitio
       Syntax.compile(source, self.dup)
     end
 
+    def resolve_proxies(recurse = true)
+      rebuilt = {}
+      scope = FetchScope.new(self, rebuilt)
+      types.each_with_object(rebuilt) do |(name,type),memo|
+        rebuilt[name] = type.resolve_proxies(scope)
+      end
+      resolved = System.new(rebuilt, imports)
+      recurse ? resolved.resolve_proxies(false) : resolved
+    end
+
     def inspect
       @types.each_pair.map{|k,v| "#{k} = #{v}" }.join("\n")
     end
@@ -97,16 +107,20 @@ module Finitio
       System.new(@types.dup, @imports.dup)
     end
 
-    def check_and_warn(io = STDERR)
+    def check_and_warn(logger = nil)
+      logger ||= begin
+        require 'logger'
+        Logger.new(STDERR)
+      end
       each_type do |t|
         next unless t.named?
         each_import do |i|
           next unless found = i.get_type(t.name)
           if found == t
-            STDERR.puts "WARN: duplicate type def `#{t.name}`"
+            logger.info "Duplicate type def `#{t.name}`"
             break
           else
-            STDERR.puts "NOTICE: Type erasure `#{t.name}`"
+            logger.warn "Type erasure `#{t.name}`"
             break
           end
         end

data/lib/finitio/type.rb

@@ -54,6 +54,20 @@ module Finitio
       raise NotImplementedError, "Missing #{self.class.name}#dress"
     end
 
+    def suppremum(other)
+      return self if other == self
+      other._suppremum(self)
+    end
+
+    def _suppremum(other)
+      UnionType.new([other, self])
+    end
+    protected :_suppremum
+
+    def unconstrained
+      self
+    end
+
     def to_s
       name.to_s
     end
@@ -64,6 +78,10 @@ module Finitio
       }
     end
 
+    def resolve_proxies(system)
+      raise NotImplementedError, "resolve_proxies must be overriden"
+    end
+
   protected
 
     def set_equal?(s1, s2)
@@ -94,3 +112,4 @@ require_relative 'type/multi_tuple_type'
 require_relative 'type/relation_type'
 require_relative 'type/multi_relation_type'
 require_relative 'type/ad_type'
+require_relative 'type/high_order_type'

data/lib/finitio/type/ad_type.rb

@@ -132,7 +132,7 @@ module Finitio
     end
 
     def hash
-      [ ruby_type, contracts ].hash
+      ruby_type.hash ^ contracts.hash
     end
 
     def ==(other)
@@ -144,5 +144,13 @@ module Finitio
     end
     alias :eql? :==
 
+    def resolve_proxies(system)
+      AdType.new(ruby_type, contracts.map{|t| t.resolve_proxies(system)}, name, metadata)
+    end
+
+    def unconstrained
+      AdType.new(ruby_type, contracts.map{|c| c.unconstrained}, name, metadata)
+    end
+
   end # class AdType
 end # module Finitio

data/lib/finitio/type/alias_type.rb

@@ -33,5 +33,13 @@ module Finitio
       end
     end
 
+    def resolve_proxies(system)
+      AliasType.new(target.resolve_proxies(system), name, metadata)
+    end
+
+    def unconstrained
+      AliasType.new(target.unconstrained, name, metadata)
+    end
+
   end # class AliasType
 end # module Finitio

data/lib/finitio/type/any_type.rb

@@ -38,6 +38,14 @@ module Finitio
       value
     end
 
+    def suppremum(other)
+      self
+    end
+
+    def _suppremum(other)
+      self
+    end
+
     def ==(other)
       super || other.is_a?(AnyType)
     end
@@ -47,5 +55,9 @@ module Finitio
       self.class.hash ^ 37
     end
 
+    def resolve_proxies(system)
+      self
+    end
+
   end # class AnyType
 end # module Finitio

data/lib/finitio/type/builtin_type.rb

@@ -53,5 +53,9 @@ module Finitio
       self.class.hash ^ ruby_type.hash
     end
 
+    def resolve_proxies(system)
+      self
+    end
+
   end # class BuiltinType
 end # module Finitio

data/lib/finitio/type/collection_type.rb

@@ -20,5 +20,20 @@ module Finitio
       self.class.hash ^ self.elm_type.hash
     end
 
+    def suppremum(other)
+      return super unless other.is_a?(CollectionType)
+      return self if other.is_a?(CollectionType) && elm_type == other.elm_type
+      builder = self.class == other.class ? self.class : SeqType
+      builder.new(elm_type.suppremum(other.elm_type))
+    end
+
+    def resolve_proxies(system)
+      self.class.new(elm_type.resolve_proxies(system), name, metadata)
+    end
+
+    def unconstrained
+      self.class.new(elm_type.unconstrained, name, metadata)
+    end
+
   end # module CollectionType
 end # module Finitio

data/lib/finitio/type/heading_based_type.rb

@@ -15,6 +15,15 @@ module Finitio
       heading.fetch(attrname)
     end
 
+    def suppremum(other, simple_class, multi_class)
+      return self if self == other
+      return super(other) unless other.is_a?(simple_class) or other.is_a?(multi_class)
+      return super(other) unless heading.looks_similar?(other.heading)
+      result_heading = heading.suppremum(other.heading)
+      builder = result_heading.multi? ? multi_class : simple_class
+      builder.new(result_heading)
+    end
+
     def ==(other)
       super || (other.is_a?(self.class) && heading == other.heading)
     end
@@ -24,5 +33,13 @@ module Finitio
       self.class.hash ^ heading.hash
     end
 
+    def resolve_proxies(system)
+      self.class.new(heading.resolve_proxies(system), name, metadata)
+    end
+
+    def unconstrained
+      self.class.new(heading.unconstrained, name, metadata)
+    end
+
   end # module HeadingBasedType
 end # module Finitio

data/lib/finitio/type/high_order_type.rb

@@ -0,0 +1,39 @@
+module Finitio
+  class HighOrderType < Type
+
+    def initialize(vars, defn, name = nil, metadata = nil)
+      super(name, metadata)
+      @vars = vars
+      @defn = defn
+    end
+    attr_reader :vars, :defn
+
+    def default_name
+      "Type<#{vars.join(',')}>"
+    end
+
+    def suppremum(other)
+      raise NotImplementedError, "Suppremum is not defined on high order types"
+    end
+
+    def ==(other)
+      super || other.is_a?(HighOrderType) \
+            && other.vars == self.vars \
+            && other.defn = self.defn
+    end
+
+    def resolve_proxies(system)
+      self
+    end
+
+    def instantiate(compilation, sub_types)
+      overrides = Hash[vars.zip(sub_types)]
+      defn.resolve_proxies(compilation.with_scope(overrides))
+    end
+
+    def unconstrained
+      HighOrderType.new(vars, defn.unconstrained, name, metadata)
+    end
+
+  end # class HighOrderType
+end # module Finitio

data/lib/finitio/type/multi_relation_type.rb

@@ -30,5 +30,9 @@ module Finitio
       "{{#{heading.to_name}}}"
     end
 
+    def suppremum(other)
+      super(other, RelationType, MultiRelationType)
+    end
+
   end # class MultiRelationType
 end # module Finitio

data/lib/finitio/type/multi_tuple_type.rb

@@ -25,5 +25,9 @@ module Finitio
       "{#{heading.to_name}}"
     end
 
+    def suppremum(other)
+      super(other, TupleType, MultiTupleType)
+    end
+
   end # class MultiTupleType
 end # module Finitio

data/lib/finitio/type/proxy_type.rb

@@ -11,30 +11,20 @@ module Finitio
     end
     attr_reader :target_name, :target
 
-    [
-      :representator,
-      :name,
-      :name=,
-      :default_name,
-      :dress,
-      :undress,
-      :include?,
-      :==,
-      :eql?,
-      :hash,
-      :to_s
-    ].each do |meth|
-      define_method(meth) do |*args, &bl|
-        raise Error, "No such type `#{@target_name}` (proxy not resolved?)" unless @target
-        @target.send(meth, *args, &bl)
-      end
+    def default_name
+      "_#{target_name}_"
     end
 
-    def resolve(system)
-      @target = system.fetch(target_name){
-        raise Error, "No such type `#{target_name}`"
+    def resolve_proxies(system)
+      system.fetch(target_name){
+        raise Error, "No such type `#{target_name}` in #{system}"
       }
     end
 
+    def unconstrained
+      return @target.unconstrained if @target
+      raise Error, "`unconstrained` cannot be call whithout proxies being resolved"
+    end
+
   end # class ProxyType
 end # module Finitio

data/lib/finitio/type/relation_type.rb

@@ -36,5 +36,9 @@ module Finitio
       "{{#{heading.to_name}}}"
     end
 
+    def suppremum(other)
+      super(other, RelationType, MultiRelationType)
+    end
+
   end # class RelationType
 end # module Finitio

data/lib/finitio/type/seq_type.rb

@@ -27,7 +27,7 @@ module Finitio
     include CollectionType
 
     def representator
-      [elmType]
+      [elm_type]
     end
 
     def include?(value)

data/lib/finitio/type/struct_type.rb

@@ -80,5 +80,13 @@ module Finitio
       self.class.hash ^ component_types.hash
     end
 
+    def resolve_proxies(system)
+      StructType.new(component_types.map{|t| t.resolve_proxies(system)}, name, metadata)
+    end
+
+    def unconstrained
+      StructType.new(component_types.map{|t| t.unconstrained}, name, metadata)
+    end
+
   end # class StructType
 end # module Finitio

data/lib/finitio/type/sub_type.rb

@@ -81,6 +81,10 @@ module Finitio
       uped
     end
 
+    def unconstrained
+      super_type.unconstrained
+    end
+
     def ==(other)
       super || (
         other.is_a?(SubType) && (other.super_type == super_type) &&
@@ -93,5 +97,9 @@ module Finitio
       self.class.hash ^ super_type.hash ^ set_hash(constraints)
     end
 
+    def resolve_proxies(system)
+      SubType.new(super_type.resolve_proxies(system), constraints, name, metadata)
+    end
+
   end # class SubType
 end # module Finitio