finitio 0.7.0.pre.rc2 → 0.9.0

data/lib/finitio/json_schema/union_type.rb

@@ -0,0 +1,11 @@
+module Finitio
+  class UnionType
+
+    def to_json_schema(*args, &bl)
+      {
+        anyOf: candidates.map{|c| c.to_json_schema(*args, &bl) }
+      }
+    end
+
+  end # class UnionType
+end # module Finitio

data/lib/finitio/support.rb

@@ -1,3 +1,21 @@
+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'
 require_relative 'support/constraint'
@@ -5,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

@@ -29,5 +29,28 @@ module Finitio
       @undresser = clazz.instance_method(:"to_#{name}")
     end
 
+    def hash
+      infotype.hash ^ dresser.hash ^ undresser.hash
+    end
+
+    def ==(other)
+      super || (
+        other.is_a?(Contract) &&
+        name == other.name &&
+        infotype == other.infotype &&
+        dresser == other.dresser &&
+        undresser == other.undresser
+      )
+    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/support/proc_with_code.rb

@@ -0,0 +1,34 @@
+module Finitio
+  class ProcWithCode < Proc
+
+    def self.new(*args, &bl)
+      return Proc.new(*args, &bl) unless args.size == 2 && bl.nil?
+
+      p = Kernel.eval("->(#{args.first}){ #{args.last} }")
+      p.instance_variable_set(:@_finitio_src, args)
+
+      def p.finitio_src
+        @_finitio_src
+      end
+
+      def p.hash
+        @_finitio_src.hash
+      end
+
+      def p.==(other)
+        super || (
+          other.is_a?(Proc) &&
+          other.respond_to?(:finitio_src) &&
+          other.finitio_src == self.finitio_src
+        )
+      end
+
+      def p.eql?(other)
+        self.==(other)
+      end
+
+      p
+    end
+
+  end # module ProcWithCode
+end # module Finitio

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/import.rb

@@ -7,7 +7,7 @@ module Finitio
 
       def compile(system)
         file = system.resolve_url(import_url)
-        imported = Finitio.system(file)
+        imported = Finitio.send(:_system, file)
         system.add_import(imported)
         system
       end

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/expression.rb

@@ -4,8 +4,7 @@ module Finitio
       include Node
 
       def compile(var_name)
-        expr = "->(#{var_name}){ #{to_str} }"
-        ::Kernel.eval(expr)
+        ProcWithCode.new(var_name, to_str)
       end
 
     end # module Expression

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
@@ -97,15 +107,21 @@ 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
       end