finitio 0.7.0 → 0.8.0

data/lib/finitio/generation/sub_type.rb

@@ -0,0 +1,9 @@
+module Finitio
+  class SubType
+
+    def generate_data(generator, world = nil)
+      generator.call(super_type, world)
+    end
+
+  end # class SubType
+end # module Finitio

data/lib/finitio/generation/union_type.rb

@@ -0,0 +1,10 @@
+module Finitio
+  class UnionType
+
+    def generate_data(generator, world = nil)
+      picked = generator.flip_one_out_of(candidates)
+      generator.call(picked, world)
+    end
+
+  end # class UnionType
+end # module Finitio

data/lib/finitio/inference.rb

@@ -0,0 +1,51 @@
+module Finitio
+  class Inference
+
+    def initialize(system, options = {})
+      @system = system
+      @options = options
+    end
+    attr_reader :system
+
+    def call(input)
+      infer_type(input)
+    end
+
+  private
+
+    def infer_type(value)
+      case value
+      when Hash
+        attrs = value.map{|k,v|
+          Attribute.new(k.to_sym, infer_type(v))
+        }
+        heading = Heading.new(attrs)
+        TupleType.new(heading)
+      when Array
+        infered = value.inject(nil){|sup, value|
+          value_type = infer_type(value)
+          sup.nil? ? value_type : sup.suppremum(value_type)
+        }
+        SeqType.new(infered.nil? ? ANY_TYPE : infered)
+      else
+        found = self.system.types.values.find{|t|
+          try_dress(t, value)
+        }
+        found ? found : ANY_TYPE
+      end
+    end
+
+    def try_dress(t, value)
+      raise "Type expected, got #{t}" unless t.is_a?(Type)
+      t.dress(value)
+      true
+    rescue Finitio::Error => ex
+      #puts %Q{[#{ex.class}] #{ex.message}}
+      nil
+    rescue => ex
+      puts %Q{[#{ex.class}] #{ex.message}\n#{ex.backtrace.join("\n")}}
+      nil
+    end
+
+  end # class Inference
+end # module Finitio

data/lib/finitio/support.rb

@@ -1,3 +1,20 @@
+module Finitio
+  module Support
+
+    def compare_attrs(h1, h2, &bl)
+      mine, yours = if bl
+        [h1.map(&bl), h2.map(&bl)]
+      elsif h1.is_a?(Hash)
+        [h1.keys, h2.keys]
+      else
+        [h1, h2]
+      end
+      [ mine & yours, mine - yours, yours - mine ]
+    end
+    module_function :compare_attrs
+
+  end # module Support
+end # module Finitio
 require_relative 'support/proc_with_code'
 require_relative 'support/metadata'
 require_relative 'support/attribute'
@@ -6,4 +23,5 @@ require_relative 'support/contract'
 require_relative 'support/heading'
 require_relative 'support/dress_helper'
 require_relative 'support/type_factory'
+require_relative 'support/fetch_scope'
 require_relative 'support/compilation'

data/lib/finitio/support/attribute.rb

@@ -55,5 +55,13 @@ module Finitio
       name.hash ^ type.hash ^ required.hash
     end
 
+    def resolve_proxies(system)
+      Attribute.new(name, type.resolve_proxies(system), required, metadata)
+    end
+
+    def unconstrained
+      Attribute.new(name, type.unconstrained, required, metadata)
+    end
+
   end # class Attribute
 end # module Finitio

data/lib/finitio/support/compilation.rb

@@ -1,19 +1,19 @@
 module Finitio
   class Compilation
 
-    def initialize(system = System.new, factory = TypeFactory.new, source = nil)
+    def initialize(system = System.new, factory = TypeFactory.new, scope = nil, source = nil)
       @system  = system
       @factory = factory
-      @proxies = []
+      @scope = scope || FetchScope.new(system, {})
       @source = source
     end
-    attr_reader :system, :factory, :proxies, :source
+    attr_reader :system, :factory, :scope, :source
 
     def self.coerce(arg, source = nil)
       case arg
-      when NilClass    then new(System.new, TypeFactory.new, source)
-      when System      then new(arg, arg.factory, source)
-      when TypeFactory then new(System.new, arg, source)
+      when NilClass    then new(System.new, TypeFactory.new, nil, source)
+      when System      then new(arg, arg.factory, nil, source)
+      when TypeFactory then new(System.new, arg, nil, source)
       else
         raise ArgumentError, "Unable to coerce `#{arg}`"
       end
@@ -48,11 +48,8 @@ module Finitio
       Pathname.new(file)
     end
 
-    def resolve_proxies!
-      proxies.each do |p|
-        p.resolve(system)
-      end
-      self
+    def resolve_proxies
+      system.resolve_proxies
     end
 
     # Delegation to Factory
@@ -63,17 +60,10 @@ module Finitio
       }
     end
 
-    def proxy(*args, &bl)
-      proxy = factory.proxy(*args, &bl)
-      proxies << proxy
-      proxy
-    end
-
     # Delegation to System
 
     [
       :add_type,
-      :fetch,
       :main,
     ].each do |meth|
       define_method(meth) do |*args, &bl|
@@ -81,5 +71,15 @@ module Finitio
       end
     end
 
+    # Delegation to FetchScope
+
+    def fetch(type_name, &bl)
+      scope.fetch(type_name, &bl)
+    end
+
+    def with_scope(overrides)
+      Compilation.new(system, factory, scope.with(overrides), source)
+    end
+
   end # class Compilation
 end # module Finitio

data/lib/finitio/support/contract.rb

@@ -44,5 +44,13 @@ module Finitio
     end
     alias :eql? :==
 
+    def resolve_proxies(system)
+      Contract.new(infotype.resolve_proxies(system), dresser, undresser, name, metadata)
+    end
+
+    def unconstrained
+      Contract.new(infotype.unconstrained, dresser, undresser, name, metadata)
+    end
+
   end # class Contract
 end # module Finitio

data/lib/finitio/support/fetch_scope.rb

@@ -0,0 +1,19 @@
+module Finitio
+  class FetchScope
+
+    def initialize(parent, overrides)
+      @parent, @overrides = parent, overrides
+    end
+
+    def fetch(name, &bl)
+      @overrides.fetch(name) do
+        @parent.fetch(name, &bl)
+      end
+    end
+
+    def with(overrides)
+      FetchScope.new(self, overrides)
+    end
+
+  end # class FetchScope
+end # module Finitio

data/lib/finitio/support/heading.rb

@@ -61,6 +61,32 @@ module Finitio
       name
     end
 
+    def looks_similar?(other)
+      return self if other == self
+      shared, mine, yours = Support.compare_attrs(attributes, other.attributes)
+      shared.length >= mine.length && shared.length >= yours.length
+    end
+
+    def suppremum(other)
+      raise ArgumentError unless other.is_a?(Heading)
+      return self if other == self
+      options = { allow_extra: allow_extra? || other.allow_extra? }
+      shared, mine, yours = Support.compare_attrs(attributes, other.attributes)
+      attributes = shared.map{|attr|
+        a1, o1 = self[attr], other[attr]
+        Attribute.new(attr, a1.type.suppremum(o1.type), a1.required && o1.required)
+      }
+      attributes += mine.map{|attrname|
+        attr = self[attrname]
+        Attribute.new(attr.name, attr.type, false)
+      }
+      attributes += yours.map{|attrname|
+        attr = other[attrname]
+        Attribute.new(attr.name, attr.type, false)
+      }
+      Heading.new(attributes, options)
+    end
+
     def ==(other)
       return nil unless other.is_a?(Heading)
       attributes == other.attributes && options == other.options
@@ -73,6 +99,15 @@ module Finitio
     attr_reader :attributes, :options
     protected   :attributes, :options
 
+    def resolve_proxies(system)
+      as = attributes.map{|k,a| a.resolve_proxies(system) }
+      Heading.new(as, options)
+    end
+
+    def unconstrained
+      Heading.new(attributes.values.map{|a| a.unconstrained }, options)
+    end
+
   private
 
     def normalize_attributes(attrs)
@@ -83,7 +118,7 @@ module Finitio
       attributes = {}
       attrs.each do |attr|
         unless attr.is_a?(Attribute)
-          raise ArgumentError, "Enumerable[Attribute] expected"
+          raise ArgumentError, "Enumerable[Attribute] expected, got a `#{attr.inspect}`"
         end
         if attributes[attr.name]
           raise ArgumentError, "Attribute names must be unique"

data/lib/finitio/syntax.rb

@@ -27,7 +27,7 @@ module Finitio
     def self.compile(source, cpl = nil)
       cpl = Compilation.coerce(cpl, source)
       parse(source, root: "system").compile(cpl)
-      cpl.resolve_proxies!.system
+      cpl.resolve_proxies
     end
 
     def self.compile_type(source, cpl = nil)

data/lib/finitio/syntax/lexer.citrus

@@ -25,7 +25,7 @@ grammar Finitio::Syntax::Lexer
   end
 
   rule type_name
-    /[A-Z][a-zA-Z]+(\.[A-Z][a-zA-Z]+)*/
+    /[A-Z][a-zA-Z]*(\.[A-Z][a-zA-Z]+)*/
   end
 
   rule builtin_type_name

data/lib/finitio/syntax/type.rb

@@ -19,9 +19,11 @@ require_relative 'type/relation_type'
 require_relative 'type/union_type'
 require_relative 'type/type_ref'
 require_relative 'type/ad_type'
+require_relative 'type/high_order_type_instantiation'
 require_relative 'type/contract'
 require_relative 'type/inline_pair'
 require_relative 'type/external_pair'
 require_relative 'type/lambda_expr'
 require_relative 'type/metadata'
 require_relative 'type/metadata_attr'
+require_relative 'type/high_order_vars'

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

@@ -0,0 +1,29 @@
+module Finitio
+  module Syntax
+    module HighOrderTypeInstantiation
+      include Node
+
+      capture :high
+      capture :vars
+
+      def compile(system)
+        target = system.fetch(high.to_s){
+          raise Error, "No such type `#{high.to_s}`"
+        }
+        raise "#{high} is not a high order type" unless target.is_a?(HighOrderType)
+
+        subs = vars.compile(system).map{|low|
+          system.fetch(low.to_s) {
+            raise Error, "No such type `#{low.to_s}`"
+          }
+        }
+        target.instantiate(system, subs)
+      end
+
+      def to_ast
+        [:high_order_type_instantiation, high.to_s, lows.to_s]
+      end
+
+    end # module HighOrderTypeInstantiation
+  end # module Syntax
+end # module Finitio

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